fixed version number

lyngweb: better syntax highlighting and code editor

.github/workflows/gradle.yml

@@ -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 }}

.github/workflows/publish.yml

@@ -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 }}
-

.gitignore

@@ -15,3 +15,4 @@ xcuserdata
 /kotlin-js-store/yarn.lock
 /test.lyng
 /sample_texts/1.txt.gz
+/kotlin-js-store/wasm/yarn.lock

.run/Tests in 'lyng.lynglib.jvmTest'.run.xml

@@ -1,42 +0,0 @@
-<!--
-  ~ 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.
-  ~
-  -->
-
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Tests in 'lyng.lynglib.jvmTest'" type="GradleRunConfiguration" factoryName="Gradle">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value=":lynglib:cleanJvmTest" />
-          <option value=":lynglib:jvmTest" />
-        </list>
-      </option>
-      <option name="vmOptions" />
-    </ExternalSystemSettings>
-    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
-    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
-    <DebugAllEnabled>false</DebugAllEnabled>
-    <RunAsTest>true</RunAsTest>
-    <method v="2" />
-  </configuration>
-</component>

.run/lyng_site [jsBrowserDevelopmentRun].run.xml

@@ -0,0 +1,24 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="lyng:site [jsBrowserDevelopmentRun]" type="GradleRunConfiguration" factoryName="Gradle">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$/site" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="--continuous" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="jsBrowserDevelopmentRun" />
+        </list>
+      </option>
+      <option name="vmOptions" />
+    </ExternalSystemSettings>
+    <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
+    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
+    <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>false</RunAsTest>
+    <method v="2" />
+  </configuration>
+</component>

CHANGELOG.md

@@ -0,0 +1,45 @@
+## Changelog
+
+### Unreleased
+
+- Language: Named arguments and named splats
+  - New call-site syntax for named arguments using colon: `name: value`.
+    - Positional arguments must come before named; positionals after a named argument inside parentheses are rejected.
+    - Trailing-lambda interaction: if the last parameter is already assigned by name (or via a named splat), a trailing `{ ... }` block is illegal.
+  - Named splats: `...` can now expand a Map into named arguments.
+    - Only string keys are allowed; non-string keys raise a clear error.
+    - Duplicate assignment across named args and named splats is an error.
+    - Ellipsis (variadic) parameters remain positional-only and cannot be named.
+  - Rationale: `=` is assignment and an expression in Lyng; `:` at call sites avoids ambiguity. Declarations keep `name: Type`; call-site casts continue to use `as` / `as?`.
+  - Documentation updated: proposals and declaring-arguments sections now cover named args/splats and error cases.
+  - Tests added covering success cases and errors for named args/splats and trailing-lambda interactions.
+
+- Tooling: Highlighters and TextMate bundle updated for named args
+  - Website/editor highlighter (lyngweb + site) works with `name: value` and `...Map("k" => v)`; added JS tests covering punctuation/operator spans for `:` and `...`.
+  - TextMate grammar updated to recognize named call arguments: `name: value` after `(` or `,` with `name` highlighted as `variable.parameter.named.lyng` and `:` as punctuation; excludes `::`.
+  - TextMate bundle version bumped to 0.0.3; README updated with details and guidance.
+
+- 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.

README.md

@@ -1,6 +1,8 @@
 # Lyng: modern scripting for kotlin multiplatform
 
-A KMP library and a standalone interpreter
+Please visit the project homepage: [https://lynglang.com](https://lynglang.com)
+
+A KMP library and a standalone interpreter. v1.0.0-SNAPSHOT is now available.
 
 - simple, compact, intuitive and elegant modern code:
 
@@ -134,7 +136,19 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
 
 # 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" - done!
 
 Planned autumn 2025. Complete dynamic language with sufficient standard library:
 
@@ -159,26 +173,25 @@ Ready features:
 - [x] dynamic fields
 - [x] function annotations
 - [x] better stack reporting
+- [x] regular exceptions + extended `when`
+- [x] multiple inheritance for user classes
 
-###  Under way: 
+## plan: v1.0 - v1.5 Stability, integration, optimizations
-
-- [ ] regular exceptions
-- [ ] multiple inheritance for user classes
-- [ ] site with integrated interpreter to give a try
-- [ ] kotlin part public API good docs, integration focused
-
-## v1.1+
-
-Planned features.
 
+- [x] site with integrated interpreter to give a try
+- [x] kotlin part public API good docs, integration focused
 - [ ] type specifications
+- [ ] language server or compose-based lyng-aware editor
 - [ ] source docs and maybe lyng.md to a standard
 - [ ] metadata first class access from lyng
+- [x] aggressive optimizations
+- [ ] JVM bytecode optimizations
 
-Further
+## After 1.5 "Ideal scripting"
+
+  Estimated winter 2027
 
 - [ ] client with GUI support based on compose multiplatform somehow
 - [ ] notebook - style workbooks with graphs, formulae, etc.
-- [ ] language server or compose-based lyng-aware editor
 
 [parallelism]: docs/parallelism.md

bin/deploy_site

@@ -0,0 +1,105 @@
+#!/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.
+#
+#
+
+function checkState() {
+  if [[ $? != 0 ]]; then
+    echo
+    echo -- rsync failed. deploy was not finished. deployed version has not been affected
+    echo
+    exit 100
+  fi
+
+}
+
+# default target settings
+case "com" in
+  com)
+    SSH_HOST=sergeych@lynglang.com # host to deploy to
+    SSH_PORT=22                             # ssh port on it
+    ROOT=/bigstore/sergeych_pub/lyng                 # directory to rsync to
+    ;;
+#  com)
+#    SSH_HOST=vvk@front-01.neurodatalab.com
+#    ROOT=/home/vvk
+#    ;;
+  *)
+    echo "*** ERROR: target not specified (use deploy com | dev)"
+    echo "*** stop"
+    exit 101
+esac
+
+die() { echo "ERROR: $*" 1>&2 ; exit 1; }
+
+./gradlew site:clean site:jsBrowserDistribution || die "compilation failed"
+
+if [[ $? != 0 ]]; then
+  echo
+  echo -- build failed. deploy aborted.
+  echo
+  exit 100
+fi
+
+#exit 0
+
+# Prepare working dir
+ssh -p ${SSH_PORT} ${SSH_HOST} "
+  cd ${ROOT}
+  rm -rd build 2>/dev/null
+  if [ -d release ]; then
+    echo copying current release
+    cp -r release build
+  else
+    echo creating first release
+    mkdir release
+    mkdir build
+  fi
+";
+
+# sync files
+SRC=./site/build/dist/js/productionExecutable
+rsync -e "ssh -p ${SSH_PORT}" -avz -r -d --delete ${SRC}/* ${SSH_HOST}:${ROOT}/build/dist
+checkState
+#rsync -e "ssh -p ${SSH_PORT}" -avz  ./static/* ${SSH_HOST}:${ROOT}/build/dist
+#checkState
+#rsync -e "ssh -p ${SSH_PORT}" -avz -r -d --delete private_data/* ${SSH_HOST}:${ROOT}/build/private_data
+#checkState
+
+echo
+echo finalizing the deploy...
+ssh -p ${SSH_PORT} ${SSH_HOST} "
+  cd ${ROOT}
+  rm -rd release~
+  mv release release~
+  mv build release
+  cd release
+  # in this project we needn't restart back when we deploy the front
+  #  ~/bin/restart_service
+";
+
+if [[ $? != 0 ]]; then
+  echo
+  echo -- finalization failed. the rease might be corrupt. rolling back is not yet implemented.
+  echo
+  exit 100
+fi
+
+echo
+echo Deploy successful
+echo
+

docs/Iterator.md

@@ -9,6 +9,9 @@ To implement the iterator you need to implement only two abstract methods:
 
 ### hasNext(): Bool
 
+    // lets test
+    // offset
+
 Should return `true` if call to `next()` will return valid next element.
 
 ### next(): Obj

docs/Map.md

@@ -1,19 +1,22 @@
 # Map
 
-Map is a mutable collection of key-value pars, where keys are unique. Maps could be created with
+Map is a mutable collection of key-value pairs, where keys are unique. You can create maps in two ways:
-constructor or `.toMap` methods. When constructing from a list, each list item must be a [Collection] with exactly 2 elements, for example, a [List].
+- with the constructor `Map(...)` or `.toMap()` helpers; and
+- with map literals using braces: `{ "key": value, id: expr, id: }`.
+
+When constructing from a list, each list item must be a [Collection] with exactly 2 elements, for example, a [List].
 
 Important thing is that maps can't contain `null`: it is used to return from missing elements.
 
-Constructed map instance is of class `Map` and implements `Collection` (and therefore `Iterable`)
+Constructed map instance is of class `Map` and implements `Collection` (and therefore `Iterable`).
 
-    val map = Map( "foo" => 1, "bar" => "buzz" )
+    val oldForm = Map( "foo" => 1, "bar" => "buzz" )
-    assert(map is Map)
+    assert(oldForm is Map)
-    assert(map.size == 2)
+    assert(oldForm.size == 2)
-    assert(map is Iterable)
+    assert(oldForm is Iterable)
     >>> void
 
-Notice usage of the `=>` operator that creates `MapEntry`, which implements also [Collection] of
+Notice usage of the `=>` operator that creates `MapEntry`, which also implements [Collection] of
 two items, first, at index zero, is a key, second, at index 1, is the value. You can use lists too.
 Map keys could be any objects (hashable, e.g. with reasonable hashCode, most of standard types are). You can access elements with indexing operator:
 
@@ -29,6 +32,36 @@ Map keys could be any objects (hashable, e.g. with reasonable hashCode, most of
     assert( map["foo"] == -1)
     >>> void
 
+## Map literals { ... }
+
+Lyng supports JavaScript-like map literals. Keys can be string literals or identifiers, and there is a handy identifier shorthand:
+
+- String key: `{ "a": 1 }`
+- Identifier key: `{ foo: 2 }` is the same as `{ "foo": 2 }`
+- Identifier shorthand: `{ foo: }` is the same as `{ "foo": foo }`
+
+Access uses brackets: `m["a"]`.
+
+    val x = 10
+    val y = 10
+    val m = { "a": 1, x: x * 2, y: }
+    assertEquals(1, m["a"])      // string-literal key
+    assertEquals(20, m["x"])     // identifier key
+    assertEquals(10, m["y"])     // identifier shorthand expands to y: y
+    >>> void
+
+Trailing commas are allowed for nicer diffs and multiline formatting:
+
+    val m = {
+        "a": 1,
+        b: 2,
+    }
+    assertEquals(1, m["a"]) 
+    assertEquals(2, m["b"]) 
+    >>> void
+
+Empty `{}` is reserved for blocks/lambdas; use `Map()` for an empty map.
+
 To remove item from the collection. use `remove`. It returns last removed item or null. Be careful if you 
 hold nulls in the map - this is not a recommended practice when using `remove` returned value. `clear()` 
 removes all.
@@ -110,4 +143,36 @@ is equal.
     assert( m1 != m3 )
     >>> void
 
+## Spreads and merging
+
+Inside map literals you can spread another map with `...` and items will be merged left-to-right; rightmost wins:
+
+    val base = { a: 1, b: 2 }
+    val m = { a: 0, ...base, b: 3, c: 4 }
+    assertEquals(1, m["a"])  // base overwrites a:0
+    assertEquals(3, m["b"])  // literal overwrites spread
+    assertEquals(4, m["c"])  // new key
+    >>> void
+
+Maps and entries can also be merged with `+` and `+=`:
+
+    val m1 = ("x" => 1) + ("y" => 2)
+    assertEquals(1, m1["x"])
+    assertEquals(2, m1["y"])
+
+    val m2 = { "a": 10 } + ("b" => 20)
+    assertEquals(10, m2["a"])
+    assertEquals(20, m2["b"])
+
+    var m3 = { a: 1 }
+    m3 += ("b" => 2)
+    assertEquals(1, m3["a"])
+    assertEquals(2, m3["b"])
+    >>> void
+
+Notes:
+- Map literals always use string keys (identifier keys are converted to strings).
+- Spreads inside map literals and `+`/`+=` merges require string keys on the right-hand side; this aligns with named-argument splats.
+- When you need computed or non-string keys, use the constructor form `Map(...)` or build entries with `=>` and then merge.
+
 [Collection](Collection.md)

docs/OOP.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:
 
@@ -266,7 +378,7 @@ The same we can provide writable dynamic fields (var-type), adding set method:
                 // constant field
                 "foo" -> "bar"
                 // mutable field
-                "bar" -> setValueForBar 
+                "bar" -> storedValueForBar 
 
                 else -> throw SymbolNotFoundException()
             }
@@ -289,9 +401,56 @@ The same we can provide writable dynamic fields (var-type), adding set method:
     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:

docs/Regex.md

@@ -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
+

docs/class_reference.md

@@ -1,24 +0,0 @@
-# Classes
-
-## Declaring
-
-    class Foo1
-    class Foo2() // same, empty constructor
-    class Foo3() { // full
-    }
-    class Foo4 { // Only body
-    }
-
-```
-class_declaration = ["abstract",] "class" [, constructor] [, body]
-constructor = "(", [field [, field]] ")
-field = [visibility ,] [access ,] name [, typedecl]
-body = [visibility] ("var", vardecl) | ("val", vardecl) | ("fun", fundecl)
-visibility = "private" | "protected" | "internal"
-```
-
-### Abstract classes
-
-Contain one pr more abstract methods which must be implemented; though they
-can have constructors, the instances of the abstract classes could not be
-created independently

docs/declaring_arguments.md

@@ -5,7 +5,7 @@ lambdas and class declarations.
 
 ## Regular
 
-## default values
+## Default values
 
 Default parameters should not be mixed with mandatory ones:
 
@@ -96,5 +96,60 @@ There could be any number of splats at any positions. You can splat any other [I
     >>> [start,1,2,3,end]
     >>> void
 
+## Named arguments in calls
+
+Lyng supports named arguments at call sites using colon syntax `name: value`:
+
+```lyng
+    fun test(a="foo", b="bar", c="bazz") { [a, b, c] }
+
+    assertEquals(["foo", "b", "bazz"], test(b: "b"))
+    assertEquals(["a", "bar", "c"], test("a", c: "c"))
+```
+
+Rules:
+
+- Named arguments must follow positional arguments. After the first named argument, no positional arguments may appear inside the parentheses.
+- The only exception is the syntactic trailing block after the call: `f(args) { ... }`. This block is outside the parentheses and is handled specially (see below).
+- A named argument cannot reassign a parameter already set positionally.
+- If the last parameter has already been assigned by a named argument (or named splat), a trailing block is not allowed and results in an error.
+
+Why `:` and not `=` at call sites? In Lyng, `=` is an expression (assignment), so we use `:` to avoid ambiguity. Declarations continue to use `:` for types, while call sites use `as` / `as?` for type operations.
+
+## Named splats (map splats)
+
+Splat (`...`) of a Map provides named arguments to the call. Only string keys are allowed:
+
+```lyng
+    fun test(a="a", b="b", c="c", d="d") { [a, b, c, d] }
+    val r = test("A?", ...Map("d" => "D!", "b" => "B!"))
+    assertEquals(["A?","B!","c","D!"], r)
+```
+
+The same with a map literal is often more concise. Define the literal, then splat the variable:
+
+    fun test(a="a", b="b", c="c", d="d") { [a, b, c, d] }
+    val patch = { d: "D!", b: "B!" }
+    val r = test("A?", ...patch)
+    assertEquals(["A?","B!","c","D!"], r)
+    >>> void
+
+Constraints:
+
+- Map splat keys must be strings; otherwise, a clean error is thrown.
+- Named splats cannot duplicate parameters already assigned (by positional or named arguments).
+- Named splats must follow all positional arguments and positional splats.
+- Ellipsis parameters (variadic) remain positional-only and cannot be assigned by name.
+
+## Trailing-lambda rule interaction
+
+If a call is immediately followed by a block `{ ... }`, it is treated as an extra last argument and bound to the last parameter. However, if the last parameter is already assigned by a named argument or a named splat, using a trailing block is an error:
+
+```lyng
+    fun f(x, onDone) { onDone(x) }
+    f(x: 1) { 42 }   // ERROR
+    f(1) { 42 }      // OK
+```
+    
 
 [tutorial]: tutorial.md

docs/development/String.md

@@ -0,0 +1,28 @@
+[//]: # (excludeFromIndex)
+
+# 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`
+```

docs/development/including_modules.md

@@ -1,5 +1,7 @@
 # Modules inclusion
 
+[//]: # (excludeFromIndex)
+
 Module is, at the low level, a statement that modifies a given context by adding
 here local and exported symbols, performing some tasks and even returning some value
 we don't need for now.

docs/development/scope_resolution.md

@@ -1,3 +1,4 @@
+[//]: # (excludeFromIndex)
 
 
 Provide:

docs/embedding.md

@@ -0,0 +1,236 @@
+# Embedding Lyng in your Kotlin project
+
+Lyng is a tiny, embeddable, Kotlin‑first scripting language. This page shows, step by step, how to:
+
+- add Lyng to your build
+- create a runtime and execute scripts
+- define functions and variables from Kotlin
+- read variable values back in Kotlin
+- call Lyng functions from Kotlin
+- create your own packages and import them in Lyng
+
+All snippets below use idiomatic Kotlin and rely on Lyng public APIs. They work on JVM and other Kotlin Multiplatform targets supported by `lynglib`.
+
+Note: all Lyng APIs shown are `suspend`, because script evaluation is coroutine‑friendly and can suspend.
+
+### 1) Add Lyng to your build
+
+Add the repository where you publish Lyng artifacts and the dependency on the core library `lynglib`.
+
+Gradle Kotlin DSL (build.gradle.kts):
+
+```kotlin
+repositories {
+    // Your standard repos
+    mavenCentral()
+
+    // If you publish to your own Maven (example: Gitea packages). Adjust URL/token as needed.
+    maven(url = uri("https://gitea.sergeych.net/api/packages/SergeychWorks/maven"))
+}
+
+dependencies {
+    // Multiplatform: place in appropriate source set if needed
+    implementation("net.sergeych:lynglib:1.0.0-SNAPSHOT")
+}
+```
+
+If you use Kotlin Multiplatform, add the dependency in the `commonMain` source set (and platform‑specific sets if you need platform APIs).
+
+### 2) Create a runtime (Scope) and execute scripts
+
+The easiest way to get a ready‑to‑use scope with standard packages is via `Script.newScope()`.
+
+```kotlin
+fun main() = kotlinx.coroutines.runBlocking {
+    val scope = Script.newScope() // suspends on first init
+
+    // Evaluate a one‑liner
+    val result = scope.eval("1 + 2 * 3")
+    println("Lyng result: $result") // ObjReal/ObjInt etc.
+}
+```
+
+You can also pre‑compile a script and execute it multiple times:
+
+```kotlin
+val script = Compiler.compile("""
+    // any Lyng code
+    val x = 40 + 2
+    x
+""")
+
+val run1 = script.execute(scope)
+val run2 = script.execute(scope)
+```
+
+`Scope.eval("...")` is a shortcut that compiles and executes on the given scope.
+
+### 3) Define variables from Kotlin
+
+To expose data to Lyng, add constants (read‑only) or mutable variables to the scope. All values in Lyng are `Obj` instances; the core types live in `net.sergeych.lyng.obj`.
+
+```kotlin
+// Read‑only constant
+scope.addConst("pi", ObjReal(3.14159))
+
+// Mutable variable: create or update
+scope.addOrUpdateItem("counter", ObjInt(0))
+
+// Use it from Lyng
+scope.eval("counter = counter + 1")
+```
+
+Tip: Lyng values can be converted back to Kotlin with `toKotlin(scope)`:
+
+```kotlin
+val current = (scope.eval("counter")).toKotlin(scope) // Any? (e.g., Int/Double/String/List)
+```
+
+### 4) Add Kotlin‑backed functions
+
+Use `Scope.addFn`/`addVoidFn` to register functions implemented in Kotlin. Inside the lambda, use `this.args` to access arguments and return an `Obj`.
+
+```kotlin
+// A function returning value
+scope.addFn<ObjInt>("inc") {
+    val x = args.firstAndOnly() as ObjInt
+    ObjInt(x.value + 1)
+}
+
+// A void function (returns Lyng Void)
+scope.addVoidFn("log") {
+    val items = args.list // List<Obj>
+    println(items.joinToString(" ") { it.toString(this).value })
+}
+
+// Call them from Lyng
+scope.eval("val y = inc(41); log('Answer:', y)")
+```
+
+You can register multiple names (aliases) at once: `addFn<ObjInt>("inc", "increment") { ... }`.
+
+### 5) Read variable values back in Kotlin
+
+The simplest approach: evaluate an expression that yields the value and convert it.
+
+```kotlin
+val kotlinAnswer = scope.eval("(1 + 2) * 3").toKotlin(scope) // -> 9 (Int)
+
+// After scripts manipulate your vars:
+scope.addOrUpdateItem("name", ObjString("Lyng"))
+scope.eval("name = name + ' rocks!'")
+val kotlinName = scope.eval("name").toKotlin(scope) // -> "Lyng rocks!"
+```
+
+Advanced: you can also grab a variable record directly via `scope.get(name)` and work with its `Obj` value, but evaluating `"name"` is often clearer and enforces Lyng semantics consistently.
+
+### 6) Execute scripts with parameters; call Lyng functions from Kotlin
+
+There are two convenient patterns.
+
+1) Evaluate a Lyng call expression directly:
+
+```kotlin
+// Suppose Lyng defines: fun add(a, b) = a + b
+scope.eval("fun add(a, b) = a + b")
+
+val sum = scope.eval("add(20, 22)").toKotlin(scope) // -> 42
+```
+
+2) Call a Lyng function by name via a prepared call scope:
+
+```kotlin
+// Ensure the function exists in the scope
+scope.eval("fun add(a, b) = a + b")
+
+// Look up the function object
+val addFn = scope.get("add")!!.value as Statement
+
+// Create a child scope with arguments (as Lyng Objs)
+val callScope = scope.createChildScope(
+    args = Arguments(listOf(ObjInt(20), ObjInt(22)))
+)
+
+val resultObj = addFn.execute(callScope)
+val result = resultObj.toKotlin(scope) // -> 42
+```
+
+If you need to pass complex data (lists, maps), construct the corresponding Lyng `Obj` types (`ObjList`, `ObjMap`, etc.) and pass them in `Arguments`.
+
+### 7) Create your own packages and import them in Lyng
+
+Lyng supports packages that are imported from scripts. You can register packages programmatically via `ImportManager` or by providing source texts that declare `package ...`.
+
+Key concepts:
+
+- `ImportManager` holds package registrations and lazily builds `ModuleScope`s when first imported.
+- Every `Scope` has `currentImportProvider` and (if it’s an `ImportManager`) a convenience `importManager` to register packages.
+
+Register a Kotlin‑built package:
+
+```kotlin
+val scope = Script.newScope()
+
+// Access the import manager behind this scope
+val im: ImportManager = scope.importManager
+
+// Register a package "my.tools"
+im.addPackage("my.tools") { module: ModuleScope ->
+    // Expose symbols inside the module scope
+    module.addConst("version", ObjString("1.0"))
+    module.addFn<ObjInt>("triple") {
+        val x = args.firstAndOnly() as ObjInt
+        ObjInt(x.value * 3)
+    }
+}
+
+// Use it from Lyng
+scope.eval("""
+    import my.tools.*
+    val v = triple(14)
+""")
+val v = scope.eval("v").toKotlin(scope) // -> 42
+```
+
+Register a package from Lyng source text:
+
+```kotlin
+val pkgText = """
+    package math.extra
+
+    fun sqr(x) = x * x
+""".trimIndent()
+
+scope.importManager.addTextPackages(pkgText)
+
+scope.eval("""
+    import math.extra.*
+    val s = sqr(12)
+""")
+val s = scope.eval("s").toKotlin(scope) // -> 144
+```
+
+You can also register from parsed `Source` instances via `addSourcePackages(source)`.
+
+### 8) Executing from files, security, and isolation
+
+- To run code from a file, read it and pass to `scope.eval(text)` or compile with `Compiler.compile(Source(fileName, text))`.
+- `ImportManager` takes an optional `SecurityManager` if you need to restrict what packages or operations are available. By default, `Script.defaultImportManager` allows everything suitable for embedded use; clamp it down in sandboxed environments.
+- For isolation, create fresh modules/scopes via `Scope.new()` or `Script.newScope()` when you need a clean environment per request.
+
+```kotlin
+// Fresh module based on the default manager, without the standard prelude
+val isolated = net.sergeych.lyng.Scope.new()
+```
+
+### 9) Tips and troubleshooting
+
+- All values that cross the boundary must be Lyng `Obj` instances. Convert Kotlin values explicitly (e.g., `ObjInt`, `ObjReal`, `ObjString`).
+- Use `toKotlin(scope)` to get Kotlin values back. Collections convert to Kotlin collections recursively.
+- Most public API in Lyng is suspendable. If you are not already in a coroutine, wrap calls in `runBlocking { ... }` on the JVM for quick tests.
+- When registering packages, names must be unique. Register before you compile/evaluate scripts that import them.
+- To debug scope content, `scope.toString()` and `scope.trace()` can help during development.
+
+---
+
+That’s it. You now have Lyng embedded in your Kotlin app: you can expose your app’s API, evaluate user scripts, and organize your own packages to import from Lyng code.

docs/math.md

@@ -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)                 |
+|        7         | bitwise and `&`                      |
-|        9         | bitwise or `\|` (NI)                 |
+|        8         | bitwise xor `^`                      |
+|        9         | bitwise or `\|`                      |
 |        10        | `&&`                                 |
 |  11<br/>lowest   | `\|\|`                               |
 
-(NI)
+Bitwise operators
-: not yet implemented.
+: 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

docs/parallelism.md

@@ -36,19 +36,19 @@ Launch has the only argument which should be a callable (lambda usually) that is
 
 ## Synchronization: Mutex
 
-Suppose we have a resource, that could be used concurrently, a coutner in our case. If we won'r protect it, concurrent usage cause RC, Race Condition, providing wrong result:
+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..4).map { 
+    (1..50).map { 
         launch {
             // slow increment:
             val c = counter
-            delay(10)
+            delay(100)
             counter = c + 1
         }
     }.forEach { it.await() }
-    assert(counter < 4)
+    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.
@@ -205,3 +205,17 @@ Flows allow easy transforming of any [Iterable]. See how the standard Lyng libra
 
 
 [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.

docs/perf_guide.md

@@ -0,0 +1,622 @@
+
+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.
+
+[//]: # (excludeFromIndex)
+
+## 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.
+

docs/perf_plan_jvm.md

@@ -0,0 +1,58 @@
+# JVM-only Performance Optimization Plan (Saved)
+
+[//]: # (excludeFromIndex)
+
+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.

docs/proposals/map_literal.md

@@ -0,0 +1,93 @@
+
+# Map literals — refined proposal
+
+Implement JavaScript-like literals for maps. The syntax and semantics align with named arguments in function calls, but map literals are expressions that construct `Map` values.
+
+Keys can be either:
+- string literals: `{ "some key": value }`, or
+- identifiers: `{ name: expr }`, where the key becomes the string `"name"`.
+
+Identifier shorthand inside map literals is supported:
+- `{ name: }` desugars to `{ "name": name }`.
+
+Property access sugar is not provided for maps: use bracket access only, e.g. `m["a"]`, not `m.a`.
+
+Examples:
+
+```lyng
+val x = 2
+val m = { "a": 1, x: x*10, y: }
+assertEquals(1, m["a"])      // string-literal key
+assertEquals(20, m["x"])     // identifier key
+assertEquals(2, m["y"])      // identifier shorthand
+```
+
+Spreads (splats) in map literals are allowed and merged left-to-right with “rightmost wins” semantics:
+
+```lyng
+val base = { a: 1, b: 2 }
+val m = { a: 0, ...base, b: 3, c: 4 }
+assertEquals(1, m["a"])  // base overwrites a:0
+assertEquals(3, m["b"])  // literal overwrites spread
+assertEquals(4, m["c"])  // new key
+```
+
+Trailing commas are allowed (optional):
+
+```lyng
+val m = {
+  "a": 1,
+  b: 2,
+  ...other,
+}
+```
+
+Duplicate keys among literal entries (including identifier shorthand) are a compile-time error:
+
+```lyng
+{ foo: 1, "foo": 2 }   // error: duplicate key "foo"
+{ foo:, foo: 2 }        // error: duplicate key "foo"
+```
+
+Spreads are evaluated at runtime. Overlaps from spreads are resolved by last write wins. If a spread is not a map, or yields a map with non-string keys, it’s a runtime error.
+
+Merging with `+`/`+=` and entries:
+
+```lyng
+("1" => 10) + ("2" => 20)     // Map("1"=>10, "2"=>20)
+{ "1": 10 } + ("2" => 20)     // same
+{ "1": 10 } + { "2": 20 }    // same
+
+var m = { "a": 1 }
+m += ("b" => 2)                 // m = { "a":1, "b":2 }
+```
+
+Rightmost wins on duplicates consistently across spreads and merges. All map merging operations require string keys; encountering a non-string key during merge is a runtime error.
+
+Empty map literal `{}` is not supported to avoid ambiguity with blocks/lambdas. Use `Map()` for an empty map.
+
+Lambda disambiguation
+- A `{ ... }` with typed lambda parameters must have a top-level `->` in its header. The compiler disambiguates by looking for a top-level `->`. If none is found, it attempts to parse a map literal; if that fails, it is parsed as a lambda or block.
+
+Grammar (EBNF)
+
+```
+ws                    = zero or more whitespace (incl. newline/comments)
+map_literal           = '{' ws map_entries ws '}'
+map_entries           = map_entry ( ws ',' ws map_entry )* ( ws ',' )?
+map_entry             = map_key ws ':' ws map_value_opt
+                      | '...' ws expression
+map_key               = string_literal | ID
+map_value_opt         = expression | ε   // ε allowed only if map_key is ID
+```
+
+Notes:
+- Identifier shorthand (`id:`) is allowed only for identifiers, not string-literal keys.
+- Spreads accept any expression; at runtime it must yield a `Map` with string keys.
+- Duplicate keys are detected at compile time among literal keys; spreads are merged at runtime with last-wins.
+
+Rationale
+- The `{ name: value }` style is familiar and ergonomic.
+- Disambiguation with lambdas leverages the required `->` in typed lambda headers.
+- Avoiding `m.a` sidesteps method/field shadowing and keeps semantics clear.
+

docs/proposals/named_args.md

@@ -0,0 +1,67 @@
+# Named arguments proposal
+
+Extend function/method calls to allow setting arguments by name using colon syntax at call sites. This is especially convenient with many parameters and default values.
+
+Examples:
+
+```lyng
+    fun test(a="foo", b="bar", c="bazz") { [a, b, c] }
+
+    assertEquals(test(b: "b"), ["foo", "b", "bazz"])
+    assertEquals(test("a", c: "c"), ["a", "bar", "c"])
+```
+
+Rules:
+
+- Named arguments are optional. If named arguments are present, their order is not important.
+- Named arguments must follow positional arguments; positional arguments cannot follow named ones (the only exception is the syntactic trailing block outside parentheses, see below).
+- A named argument cannot reassign a parameter already set positionally.
+- If the last parameter is already assigned by a named argument (or named splat), the trailing-lambda rule must NOT apply: a following `{ ... }` after the call is an error.
+
+Rationale for using `:` instead of `=` in calls: in Lyng, assignment `=` is an expression; using `:` avoids ambiguity and keeps declarations (`name: Type`) distinct from call sites, where casting uses `as` / `as?`.
+
+Migration note: earlier drafts/examples used `name = value`. The final syntax is `name: value` at call sites.
+
+## Extended call argument splats: named splats
+
+With named arguments, splats (`...`) are extended to support maps as named splats. When a splat evaluates to a Map, its entries provide name→value assignments:
+
+```lyng
+    fun test(a="a", b="b", c="c", d="d") { [a, b, c, d] }
+
+    assertEquals(test("A?", ...Map("d" => "D!", "b" => "B!")), ["A?", "B!", "c", "D!"])
+```
+
+Constraints for named splats:
+
+- Only string keys are allowed in map splats; otherwise, a clean error is thrown.
+- Named splats cannot reassign parameters already set (positionally or by earlier named arguments/splats).
+- Named splats follow the same ordering as named arguments: they must appear after all positional arguments and positional splats.
+
+## Trailing-lambda interaction
+
+Lyng supports a syntactic trailing block after a call: `f(args) { ... }`. With named args/splats, if the last parameter is already assigned by name, the trailing block must not apply and the call is an error:
+
+```lyng
+    fun f(x, onDone) { onDone(x) }
+    f(x: 1) { 42 }    // ERROR: last parameter already assigned by name
+    f(1) { 42 }       // OK
+```
+
+## Errors (non-exhaustive)
+
+- Positional argument after any named argument inside parentheses: error.
+- Positional splat after any named argument: error.
+- Duplicate named assignment (directly or via map splats): error.
+- Unknown parameter name in a named argument/splat: error.
+- Map splat with non-string keys: error.
+- Attempt to target the ellipsis parameter by name: error.
+
+## Notes
+
+- Declarations continue to use `:` for types, while call sites use `:` for named arguments and `as` / `as?` for type casts/checks.
+
+
+
+
+

docs/samples/happy_numbers.lyng.bad

@@ -19,12 +19,13 @@ fun naiveCountHappyNumbers() {
 import lyng.time
 
 //
-// After all optimizations it takes ~120ms.
+// After all optimizations it took ~120ms - before.
 //
-//for( r in 1..100 ) {
+for( r in 1..900 ) {
-//    val start = Instant.now()
+    val start = Instant.now()
     val found = naiveCountHappyNumbers()
-//    println("Found happy numbers: %d time %s"(found, Instant.now() - start))
+    println("Found happy numbers: %d time %s"(found, Instant.now() - start))
     assert( found == 55252 )
-//    delay(0.01)
+    delay(0.05)
-//}
+}
+

docs/samples/sum.lyng

@@ -1,7 +1,7 @@
+#!/bin/env lyng
 /*
     Calculate the limit of Sum( f(n) )
     until it reaches asymptotic limit 0.00001% change
-
     return null or found limit
 */
 fun findSumLimit(f) {

docs/tutorial.md

@@ -1,8 +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
@@ -13,7 +8,7 @@ __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)
+- [math in Lyng](math.md), [the `when` statement](when.md)
 - [time](time.md) and [parallelism](parallelism.md)
 - [parallelism] - multithreaded code, coroutines, etc.
 - Some class
@@ -275,6 +270,8 @@ Logical operation could be used the same
 |   ===    |     | Any               | (2)      |
 |   !==    |     | Any               | (2)      |
 |    !=    |     | Any               | (1)      |
+|    =~    |     |                   | (3)      |
+|    !~    |     |                   | (3)      |
 | ++a, a++ |     | Int               |          |
 | --a, a-- |     | Int               |          |
 
@@ -286,6 +283,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
@@ -676,14 +676,63 @@ Please see [Set] for detailed description.
 
 # Maps
 
-Maps are unordered collection of key-value pairs, where keys are unique. See [Map] for details. Map also
+Maps are unordered collections of key-value pairs, where keys are unique. Maps are also [Iterable].
-are [Iterable]:
 
-    val m = Map( "foo" => 77, "bar" => "buzz" )
+You can create them either with the classic constructor (still supported):
-    assertEquals( m["foo"], 77 )
+
+    val old = Map( "foo" => 77, "bar" => "buzz" )
+    assertEquals( old["foo"], 77 )
     >>> void
 
-Please see [Map] reference for detailed description on using Maps.
+…or with map literals, which are often more convenient:
+
+    val x = 10
+    val y = 10
+    val m = { "a": 1, x: x * 2, y: }
+    // identifier keys become strings; `y:` is shorthand for y: y
+    assertEquals(1, m["a"])      // string-literal key
+    assertEquals(20, m["x"])     // identifier key
+    assertEquals(10, m["y"])     // shorthand
+    >>> void
+
+Map literals support trailing commas for nicer diffs:
+
+    val m2 = {
+        "a": 1,
+        b: 2,
+    }
+    assertEquals(1, m2["a"]) 
+    assertEquals(2, m2["b"]) 
+    >>> void
+
+You can spread other maps inside a literal with `...`. Items merge left-to-right and the rightmost value wins:
+
+    val base = { a: 1, b: 2 }
+    val merged = { a: 0, ...base, b: 3, c: 4 }
+    assertEquals(1, merged["a"])  // base overwrites a:0
+    assertEquals(3, merged["b"])  // literal overwrites spread
+    assertEquals(4, merged["c"])  // new key
+    >>> void
+
+Merging also works with `+` and `+=`, and you can combine maps and entries conveniently:
+
+    val m3 = { "a": 10 } + ("b" => 20)
+    assertEquals(10, m3["a"]) 
+    assertEquals(20, m3["b"]) 
+
+    var m4 = ("x" => 1) + ("y" => 2)      // entry + entry → Map
+    m4 += { z: 3 }                          // merge literal
+    assertEquals(1, m4["x"]) 
+    assertEquals(2, m4["y"]) 
+    assertEquals(3, m4["z"]) 
+    >>> void
+
+Notes:
+- Access keys with brackets: `m["key"]`. There is no `m.key` sugar.
+- Empty `{}` remains a block/lambda; use `Map()` to create an empty map.
+- When you need computed (expression) keys or non-string keys, use `Map(...)` constructor with entries, e.g. `Map( ("a" + "b") => 1 )`, then merge with a literal if needed: `{ base: } + (computedKey => 42)`.
+
+Please see the [Map] reference for a deeper guide.
 
 # Flow control operators
 
@@ -712,6 +761,8 @@ Or, more neat:
 
 ## When
 
+See also: [Comprehensive guide to `when`](when.md)
+
 It is very much like the kotlin's:
 
     fun type(x) {
@@ -1184,13 +1235,38 @@ 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         |
+| \r     | 0x13, carriage return |
 | \t     | 0x07, tabulation      |
 | \\     | \ slash character     |
 | \'     | ' apostrophe          |
@@ -1262,7 +1338,23 @@ 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:
 
@@ -1280,17 +1372,23 @@ Typical set of String functions includes:
 | 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                                         |
+| [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
 
 String literal could be multiline:
@@ -1318,8 +1416,8 @@ if blank, will be removed too, for example:
 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   |
+| assert(condition, fn)                 | (1) runtime code check with generic or custom nessage `fn` |
 | assertEquals(a,b)                     |                                                            |
 | assertNotEquals(a,b)                  |                                                            |
 | assertTrows { /* block */ }           |                                                            |
@@ -1332,6 +1430,12 @@ See [math functions](math.md). Other general purpose functions are:
 | 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
 
 | name                                | description                  |
@@ -1349,7 +1453,7 @@ See [math functions](math.md). Other general purpose functions are:
 
 [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
 
@@ -1364,3 +1468,72 @@ See [math functions](math.md). Other general purpose functions are:
 [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.
+
+To get details on OOP in Lyng, see [OOP notes](oop.md).

docs/when.md

@@ -0,0 +1,239 @@
+# The `when` statement (expression)
+
+Lyng provides a concise multi-branch selection with `when`, heavily inspired by Kotlin. In Lyng, `when` is an expression: it evaluates to a value. If the selected branch contains no value (e.g., it ends with `void` or calls a void function like `println`), the whole `when` expression evaluates to `void`.
+
+Currently, Lyng implements the "subject" form: `when(value) { ... }`. The subject-less form `when { condition -> ... }` is not implemented yet.
+
+## Quick examples
+
+    val r1 = when("a") {
+        "a" -> "ok"
+        else -> "nope"
+    }
+    assertEquals("ok", r1)
+    
+    val r2 = when(5) {
+        3 -> "no"
+        4 -> "no"
+        else -> "five"
+    }
+    assertEquals("five", r2)
+    
+    val r3 = when(5) {
+        3 -> "no"
+        4 -> "no"
+    }
+    // no matching case and no else → `void`
+    assert(r3 == void)
+    >>> void
+
+## Syntax
+
+    when(subject) {
+        condition1 [, condition2, ...] -> resultExpressionOrBlock
+        conditionN -> result
+        else -> fallback
+    }
+
+- Commas group multiple conditions for one branch.
+- First matching branch wins; there is no fall‑through.
+- `else` is optional. If omitted and nothing matches, the result is `void`.
+
+## Matching rules (conditions)
+
+Within `when(subject)`, each condition is evaluated against the already evaluated `subject`. Lyng supports:
+
+1) Equality match (default)
+- Any expression value can be used as a condition. It matches if it is equal to `subject`.
+- Equality relies on Lyng’s comparison (`compareTo(...) == 0`). For user types, implement comparison accordingly.
+
+    when(x) {
+        0 -> "zero"
+        "EUR" -> "currency"
+    }
+    >>> void
+
+2) Type checks: `is` and `!is`
+- Check whether the subject is an instance of a class.
+- Works with built‑in classes and user classes.
+
+    fun typeOf(x) {
+        when(x) {
+            is Real, is Int -> "number"
+            is String -> "string"
+            else -> "other"
+        }
+    }
+    assertEquals("number", typeOf(5))
+    assertEquals("string", typeOf("hi"))
+    >>> void
+
+3) Containment checks: `in` and `!in`
+- `in container` matches if `container.contains(subject)` is true.
+- `!in container` matches if `contains(subject)` is false.
+- Any object that provides `contains(item)` can act as a container.
+
+Common containers:
+- Ranges (e.g., `'a'..'z'`, `1..10`, `1..<10`, `..5`, `5..`)
+- Lists, Sets, Arrays, Buffers
+- Strings (character or substring containment)
+
+Examples:
+
+    when('e') {
+        in 'a'..'c' -> "small"
+        in 'a'..'z' -> "letter"
+        else -> "other"
+    }
+    >>> "letter"
+    
+    when(5) {
+        in [1,2,3,4,6] -> "no"
+        in [7,0,9] -> "no"
+        else -> "ok"
+    }
+    >>> "ok"
+    
+    when(5) {
+        in [1,2,3,4,6] -> "no"
+        in [7,0,9] -> "no"
+        in [-1,5,11] -> "yes"
+        else -> "no"
+    }
+    >>> "yes"
+    
+    when(5) {
+        !in [1,2,3,4,6,5] -> "no"
+        !in [7,0,9,5] -> "no"
+        !in [-1,15,11] -> "ok"
+        else -> "no"
+    }
+    >>> "ok"
+    
+    // String containment
+    "foo" in "foobar"   // true (substring)
+    'o' in "foobar"      // true (character)
+    >>> true
+
+Notes on mixed String/Char ranges:
+- Prefer character ranges for characters: `'a'..'z'`.
+- `"a".."z"` is a String range and may not behave as you expect with `Char` subjects.
+
+    assert( "more" in "a".."z")
+    assert( 'x' !in "a".."z")  // Char vs String range: often not what you want
+    assert( 'x' in 'a'..'z')     // OK
+    assert( "x" !in 'a'..'z')   // String in Char range: likely not intended
+    >>> void
+
+## Grouping multiple conditions with commas
+
+You can group values and/or `is`/`in` checks for a single result:
+
+    fun classify(x) {
+        when(x) {
+            "42", 42 -> "answer"
+            is Real, is Int -> "number"
+            in ['@', '#', '^'] -> "punct1"
+            in "*&.," -> "punct2"
+            else -> "unknown"
+        }
+    }
+    assertEquals("number", classify(π/2))
+    assertEquals("answer", classify(42))
+    assertEquals("answer", classify("42"))
+    >>> void
+
+## Return value and blocks
+
+- `when` returns the value of the matched branch result expression/block.
+- Branch bodies can be single expressions or blocks `{ ... }`.
+- If a matched branch produces `void` (e.g., only prints), the `when` result is `void`.
+
+    val res = when(2) {
+        1 -> 10
+        2 -> { println("two"); 20 }
+        else -> 0
+    }
+    assertEquals(20, res)
+    >>> void
+
+## Else branch
+
+- Optional but recommended when non‑exhaustive.
+- If omitted and nothing matches, `when` result is `void` (see r3 in the Quick examples).
+- Only one `else` is allowed.
+
+## Subject‑less `when`
+
+The Kotlin‑style subject‑less form `when { condition -> ... }` is not implemented yet in Lyng. Use `if/else` chains or structure your checks around a subject with `when(subject) { ... }`.
+
+## Extending `when` for your own types
+
+### Equality matches
+- Equality checks in `when(subject)` use Lyng comparison (`compareTo` semantics under the hood). For your own Lyng classes, implement comparison appropriately so that `subject == value` works as intended.
+
+### `in` / `!in` containment
+- Provide a `contains(item)` method on your class to participate in `in` conditions.
+- Example: a custom `Box` that contains one specific item:
+
+    class Box(val item)
+    fun Box.contains(x) { x == item }
+    
+    val b = Box(10)
+    when(10) { in b -> "hit" }
+    >>> "hit"
+
+Any built‑in collection (`List`, `Set`, `Array`), `Range`, `Buffer`, and other containers already implement `contains`.
+
+### Type checks (`is` / `!is`)
+- Every value has a `::class` that yields its Lyng class object, e.g. `[1,2,3]::class` → `List`.
+- `is ClassName` in `when` uses Lyng’s class hierarchy. Ensure your class is declared and can be referenced by name.
+
+    []::class == List
+    >>> true
+    
+    fun f(x) { when(x) { is List -> "list" else -> "other" } }
+    assertEquals("list", f([1]))
+    >>> void
+
+## Kotlin‑backed classes (embedding)
+
+When embedding Lyng in Kotlin, you may expose Kotlin‑backed objects and classes. Interactions inside `when` work as follows:
+- `is` checks use the Lyng class object you expose for your Kotlin type. Ensure your exposed class participates in the Lyng class hierarchy (see Embedding docs).
+- `in` checks call `contains(subject)`; if your Kotlin‑backed object wants to support `in`, expose a `contains(item)` method (mapped to Lyng) or implement the corresponding Lyng container wrapper.
+- Equality follows Lyng comparison rules. Ensure your Kotlin‑backed object’s Lyng adapter implements equality/compare correctly.
+
+For details on exposing classes/methods from Kotlin, see: [Embedding Lyng in your Kotlin project](embedding.md).
+
+## Gotchas and tips
+
+- First match wins; there is no fall‑through. Order branches carefully.
+- Group related conditions with commas for readability and performance (a single branch evaluation).
+- Prefer character ranges for character tests; avoid mixing `String` and `Char` ranges.
+- If you rely on `in`, check that your container implements `contains(item)`.
+- Remember: `when` is an expression — you can assign its result to a variable or return it from a function.
+
+## Additional examples
+
+    fun label(ch) {
+        when(ch) {
+            in '0'..'9' -> "digit"
+            in 'a'..'z', in 'A'..'Z' -> "letter"
+            '$' -> "dollar"
+            else -> "other"
+        }
+    }
+    assertEquals("digit", label('3'))
+    assertEquals("dollar", label('$'))
+    >>> void
+
+    fun normalize(x) {
+        when(x) {
+            is Int -> x
+            is Real -> x.round()
+            else -> 0
+        }
+    }
+    assertEquals(12, normalize(12))
+    assertEquals(3,  normalize(2.6))
+    >>> void

editors/lyng-textmate/README.md

@@ -0,0 +1,68 @@
+Lyng TextMate grammar
+======================
+
+This folder contains a TextMate grammar for the Lyng language so you can get syntax highlighting quickly in:
+
+- JetBrains IDEs (IntelliJ IDEA, Fleet, etc.) via “TextMate Bundles”
+- VS Code (via “Install from VSIX” or by adding as an extension folder)
+
+Files
+-----
+- `package.json` — VS Code–style wrapper that JetBrains IDEs can import as a TextMate bundle.
+- `syntaxes/lyng.tmLanguage.json` — the grammar. It highlights:
+  - Line and block comments (`//`, `/* */`)
+  - Shebang line at file start (`#!...`)
+  - Strings: single and double quotes with escapes
+  - Char literals `'x'` with escapes
+  - Numbers: decimal with underscores and exponents, and hex (`0x...`)
+  - Keywords (control and declarations), boolean operator words (`and`, `or`, `not`, `in`, `is`, `as`, `as?`)
+  - Composite textual operators: `not in`, `not is`
+  - Constants: `true`, `false`, `null`, `this`
+  - Annotations: `@name` (Unicode identifiers supported)
+  - Labels: `name:` (Unicode identifiers supported)
+  - Declarations: highlights declared names in `fun|fn name`, `class|enum Name`, `val|var name`
+  - Types: built-ins (`Int|Real|String|Bool|Char|Regex`) and Capitalized identifiers (heuristic)
+  - Operators including ranges (`..`, `..<`, `...`), null-safe (`?.`, `?[`, `?(`, `?{`, `?:`, `??`), arrows (`->`, `=>`, `::`), match operators (`=~`, `!~`), bitwise, arithmetic, etc.
+  - Shuttle operator `<=>`
+  - Division operator `/` (note: Lyng has no regex literal syntax; `/` is always division)
+  - Named arguments at call sites `name: value` (the `name` part is highlighted as `variable.parameter.named.lyng` and the `:` as punctuation). The rule is anchored to `(` or `,` and excludes `::` to avoid conflicts.
+
+Install in IntelliJ IDEA (and other JetBrains IDEs)
+---------------------------------------------------
+1. Open Settings / Preferences → Editor → TextMate Bundles.
+2. Click “+” and select this folder `editors/lyng-textmate/` (the folder that contains `package.json`).
+3. Ensure `*.lyng` is associated with the Lyng grammar (IntelliJ usually picks this up from `fileTypes`).
+4. Optional: customize colors with Settings → Editor → Color Scheme → TextMate.
+
+Enable Markdown code-fence highlighting in IntelliJ
+--------------------------------------------------
+1. Settings / Preferences → Languages & Frameworks → Markdown → Code style → Code fences → Languages.
+2. Add mapping: language id `lyng` → “Lyng (TextMate)”.
+3. Now blocks like
+   ```
+   ```lyng
+   // Lyng code here
+   ```
+   ```
+   will be highlighted.
+
+Install in VS Code
+------------------
+Fastest local install without packaging:
+1. Copy or symlink this folder somewhere stable (or keep it in your workspace).
+2. Use “Developer: Install Extension from Location…” (Insiders) or package with `vsce package` and install the resulting `.vsix`.
+3. VS Code will auto-associate `*.lyng` via this extension; if needed, check File Associations.
+
+Notes and limitations
+---------------------
+- Type highlighting is heuristic (Capitalized identifiers). The IntelliJ plugin will use language semantics and avoid false positives.
+- If your language adds or changes tokens, please update patterns in `lyng.tmLanguage.json`. The Kotlin sources in `lynglib/src/commonMain/kotlin/net/sergeych/lyng/highlight/` are a good reference for token kinds.
+- Labels `name:` at statement level remain supported and are kept distinct from named call arguments by context. The grammar prefers named-argument matching when a `name:` appears right after `(` or `,`.
+
+Lyng specifics
+--------------
+- There are no regex literal tokens in Lyng at the moment; the slash character `/` is always treated as the division operator. The grammar intentionally does not define a `/.../` regex rule to avoid mis-highlighting lines like `a / b`.
+
+Contributing
+------------
+Pull requests to refine patterns and add tests/samples are welcome. You can place test snippets in `sample_texts/` and visually verify.

editors/lyng-textmate/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "lyng-textmate",
+  "displayName": "Lyng",
+  "description": "TextMate grammar for the Lyng language (for JetBrains IDEs via TextMate Bundles and VS Code).",
+  "version": "0.0.3",
+  "publisher": "lyng",
+  "license": "Apache-2.0",
+  "engines": { "vscode": "^1.0.0" },
+  "contributes": {
+    "languages": [
+      {
+        "id": "lyng",
+        "aliases": ["Lyng", "lyng"],
+        "extensions": [".lyng"]
+      }
+    ],
+    "grammars": [
+      {
+        "language": "lyng",
+        "scopeName": "source.lyng",
+        "path": "./syntaxes/lyng.tmLanguage.json"
+      }
+    ]
+  }
+}

editors/lyng-textmate/syntaxes/lyng.tmLanguage.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "Lyng",
+  "scopeName": "source.lyng",
+  "fileTypes": ["lyng"],
+  "patterns": [
+    { "include": "#shebang" },
+    { "include": "#comments" },
+    { "include": "#strings" },
+    { "include": "#char" },
+    { "include": "#numbers" },
+    { "include": "#declarations" },
+    { "include": "#keywords" },
+    { "include": "#constants" },
+    { "include": "#types" },
+    { "include": "#mapLiterals" },
+    { "include": "#namedArgs" },
+    { "include": "#annotations" },
+    { "include": "#labels" },
+    { "include": "#directives" },
+    { "include": "#operators" },
+    { "include": "#punctuation" }
+  ],
+  "repository": {
+    "shebang": { "patterns": [ { "name": "comment.line.shebang.lyng", "match": "^#!.*$" } ] },
+    "comments": {
+      "patterns": [
+        { "name": "comment.line.double-slash.lyng", "match": "//.*$" },
+        { "name": "comment.block.lyng", "begin": "/\\*", "end": "\\*/" }
+      ]
+    },
+    "strings": {
+      "patterns": [
+        { "name": "string.quoted.double.lyng", "begin": "\"", "end": "\"", "patterns": [ { "match": "\\\\.", "name": "constant.character.escape.lyng" } ] },
+        { "name": "string.quoted.single.lyng", "begin": "'", "end": "'", "patterns": [ { "match": "\\\\.", "name": "constant.character.escape.lyng" } ] }
+      ]
+    },
+    "char": { "patterns": [ { "name": "constant.character.lyng", "match": "'(?:[^\\\\']|\\\\.)'" } ] },
+    "numbers": {
+      "patterns": [
+        { "name": "constant.numeric.hex.lyng", "match": "0x[0-9A-Fa-f_]+" },
+        { "name": "constant.numeric.decimal.lyng", "match": "(?<![A-Za-z_])(?:[0-9][0-9_]*)\\.(?:[0-9_]+)(?:[eE][+-]?[0-9_]+)?|(?<![A-Za-z_])(?:[0-9][0-9_]*)(?:[eE][+-]?[0-9_]+)?" }
+      ]
+    },
+    "annotations": { "patterns": [ { "name": "entity.name.label.at.lyng", "match": "@[\\p{L}_][\\p{L}\\p{N}_]*:" }, { "name": "storage.modifier.annotation.lyng", "match": "@[\\p{L}_][\\p{L}\\p{N}_]*" } ] },
+    "mapLiterals": {
+      "patterns": [
+        {
+          "name": "meta.map.entry.lyng",
+          "match": "(?:(?<=\\{|,))\\s*(\"[^\"]*\"|[\\p{L}_][\\p{L}\\p{N}_]*)\\s*(:)(?!:)",
+          "captures": {
+            "1": { "name": "variable.other.property.key.lyng" },
+            "2": { "name": "punctuation.separator.colon.lyng" }
+          }
+        },
+        {
+          "name": "meta.map.spread.lyng",
+          "match": "(?:(?<=\\{|,))\\s*(\\.\\.\\.)",
+          "captures": {
+            "1": { "name": "keyword.operator.spread.lyng" }
+          }
+        }
+      ]
+    },
+    "namedArgs": {
+      "patterns": [
+        {
+          "name": "meta.argument.named.lyng",
+          "match": "(?:(?<=\\()|(?<=,))\\s*([\\p{L}_][\\p{L}\\p{N}_]*)\\s*(:)(?!:)",
+          "captures": {
+            "1": { "name": "variable.parameter.named.lyng" },
+            "2": { "name": "punctuation.separator.colon.lyng" }
+          }
+        }
+      ]
+    },
+    "labels": { "patterns": [ { "name": "entity.name.label.lyng", "match": "[\\p{L}_][\\p{L}\\p{N}_]*:" } ] },
+    "directives": { "patterns": [ { "name": "meta.directive.lyng", "match": "^\\s*#[_A-Za-z][_A-Za-z0-9]*" } ] },
+    "declarations": { "patterns": [ { "name": "meta.function.declaration.lyng", "match": "\\b(?:fun|fn)\\s+([\\p{L}_][\\p{L}\\p{N}_]*)", "captures": { "1": { "name": "entity.name.function.lyng" } } }, { "name": "meta.type.declaration.lyng", "match": "\\b(?:class|enum)\\s+([\\p{L}_][\\p{L}\\p{N}_]*)", "captures": { "1": { "name": "entity.name.type.lyng" } } }, { "name": "meta.variable.declaration.lyng", "match": "\\b(?:val|var)\\s+([\\p{L}_][\\p{L}\\p{N}_]*)", "captures": { "1": { "name": "variable.other.declaration.lyng" } } } ] },
+    "keywords": { "patterns": [ { "name": "keyword.control.lyng", "match": "\\b(?:if|else|when|while|do|for|try|catch|finally|throw|return|break|continue)\\b" }, { "name": "keyword.declaration.lyng", "match": "\\b(?:fun|fn|class|enum|val|var|import|package|constructor|property|open|extern|private|protected|static)\\b" }, { "name": "keyword.operator.word.lyng", "match": "\\bnot\\s+(?:in|is)\\b" }, { "name": "keyword.operator.word.lyng", "match": "\\b(?:and|or|not|in|is|as|as\\?)\\b" } ] },
+    "constants": { "patterns": [ { "name": "constant.language.lyng", "match": "(?:\\b(?:true|false|null|this)\\b|π)" } ] },
+    "types": { "patterns": [ { "name": "storage.type.lyng", "match": "\\b(?:Int|Real|String|Bool|Char|Regex)\\b" }, { "name": "entity.name.type.lyng", "match": "\\b[A-Z][A-Za-z0-9_]*\\b(?!\\s*\\()" } ] },
+    "operators": { "patterns": [ { "name": "keyword.operator.comparison.lyng", "match": "===|!==|==|!=|<=|>=|<|>" }, { "name": "keyword.operator.shuttle.lyng", "match": "<=>" }, { "name": "keyword.operator.arrow.lyng", "match": "=>|->|::" }, { "name": "keyword.operator.range.lyng", "match": "\\.\\.\\.|\\.\\.<|\\.\\." }, { "name": "keyword.operator.nullsafe.lyng", "match": "\\?\\.|\\?\\[|\\?\\(|\\?\\{|\\?:|\\?\\?" }, { "name": "keyword.operator.assignment.lyng", "match": "(?:\\+=|-=|\\*=|/=|%=|=)" }, { "name": "keyword.operator.logical.lyng", "match": "&&|\\|\\|" }, { "name": "keyword.operator.bitwise.lyng", "match": "<<|>>|&|\\||\\^|~" }, { "name": "keyword.operator.match.lyng", "match": "=~|!~" }, { "name": "keyword.operator.arithmetic.lyng", "match": "\\+\\+|--|[+\\-*/%]" }, { "name": "keyword.operator.other.lyng", "match": "[!?]" } ] },
+    "punctuation": { "patterns": [ { "name": "punctuation.separator.comma.lyng", "match": "," }, { "name": "punctuation.terminator.statement.lyng", "match": ";" }, { "name": "punctuation.section.block.begin.lyng", "match": "[(]{1}|[{]{1}|\\[" }, { "name": "punctuation.section.block.end.lyng", "match": "[)]{1}|[}]{1}|\\]" }, { "name": "punctuation.accessor.dot.lyng", "match": "\\." }, { "name": "punctuation.separator.colon.lyng", "match": ":" } ] }
+  }
+}

gradle.properties

@@ -29,3 +29,9 @@ android.nonTransitiveRClass=true
 
 # other
 kotlin.native.cacheKind.linuxX64=none
+
+# Workaround: Ensure Gradle uses a JDK with `jlink` available for AGP's JDK image transform.
+# On this environment, the system JDK 21 installation lacks `jlink`, causing
+# :lynglib:androidJdkImage to fail. Point Gradle to JDK 17 which includes `jlink`.
+# This affects only the JDK Gradle runs with; Kotlin/JVM target remains compatible.
+#org.gradle.java.home=/usr/lib/jvm/java-17-openjdk-amd64

gradle/libs.versions.toml

@@ -1,10 +1,10 @@
 [versions]
 agp = "8.5.2"
 clikt = "5.0.3"
-kotlin = "2.1.21"
+kotlin = "2.2.21"
 android-minSdk = "24"
 android-compileSdk = "34"
-kotlinx-coroutines = "1.9.0"
+kotlinx-coroutines = "1.10.2"
 mp_bintools = "0.1.12"
 firebaseCrashlyticsBuildtools = "3.0.3"
 okioVersion = "3.10.2"

lyng/build.gradle.kts

@@ -16,7 +16,7 @@
  */
 
 plugins {
-    kotlin("multiplatform") version "2.1.21"
+    alias(libs.plugins.kotlinMultiplatform)
 }
 
 group = "net.sergeych"
@@ -31,6 +31,15 @@ repositories {
 }
 
 kotlin {
+    // Suppress Beta warning for expect/actual classes across all targets in this module
+    targets.configureEach {
+        compilations.configureEach {
+            compilerOptions.configure {
+                freeCompilerArgs.add("-Xexpect-actual-classes")
+            }
+        }
+    }
+
     jvm {
         binaries {
             executable {

lyng/src/commonMain/kotlin/Common.kt

@@ -86,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 = """

lyng/src/jvmMain/kotlin/net/sergeych/lyng_cli/Benchmark.kt

@@ -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")
+        }
+    }
+}

lyng/src/jvmMain/kotlin/net/sergeych/lyng_cli/Main.kt

@@ -20,5 +20,9 @@ package net.sergeych.lyng_cli
 import net.sergeych.runMain
 
 fun main(args: Array<String>) {
+    if (args.contains("--benchmark")) {
+        BenchmarkRunner.runAll()
+        return
+    }
     runMain(args)
 }

lynglib/build.gradle.kts

@@ -21,23 +21,15 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 group = "net.sergeych"
-version = "0.8.15-SNAPSHOT"
+version = "1.0.4-SNAPSHOT"
 
-buildscript {
+// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
-    repositories {
-        mavenCentral()
-    }
-    dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.0")
-        classpath("com.codingfeline.buildkonfig:buildkonfig-gradle-plugin:latest_version")
-    }
-}
 
 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.2.21"
     id("com.codingfeline.buildkonfig") version "0.17.1"
     `maven-publish`
 }
@@ -62,10 +54,14 @@ kotlin {
             jvmTarget.set(JvmTarget.JVM_11)
         }
     }
-//    iosX64()
+    iosX64()
-//    iosArm64()
+    iosArm64()
-//    iosSimulatorArm64()
+    iosSimulatorArm64()
+    macosX64()
+    macosArm64()
+    mingwX64()
     linuxX64()
+    linuxArm64()
     js {
         browser()
         nodejs()
@@ -76,13 +72,23 @@ kotlin {
         nodejs()
     }
 
+    // Suppress Beta warning for expect/actual classes across all targets
+    targets.configureEach {
+        compilations.configureEach {
+            compilerOptions.configure {
+                freeCompilerArgs.add("-Xexpect-actual-classes")
+            }
+        }
+    }
+
     sourceSets {
         all {
             languageSettings.optIn("kotlinx.coroutines.ExperimentalCoroutinesApi")
-            languageSettings.optIn("kotlin.contracts.ExperimentalContracts")
             languageSettings.optIn("kotlin.ExperimentalUnsignedTypes")
-            languageSettings.optIn("kotlin.coroutines.DelicateCoroutinesApi")
+            // Correct opt-in markers for coroutines
-            languageSettings.optIn("kotlinx.coroutines.flow.DelicateCoroutinesApi")
+            languageSettings.optIn("kotlinx.coroutines.DelicateCoroutinesApi")
+            languageSettings.optIn("kotlin.contracts.ExperimentalContracts")
+            languageSettings.optIn("kotlinx.coroutines.FlowPreview")
         }
 
         val commonMain by getting {
@@ -138,6 +144,47 @@ 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
+
+    // Benchmarks toggle: disabled by default, enable when optimizing locally.
+    // Enable via any of the following:
+    //  - Gradle property:  ./gradlew :lynglib:jvmTest -Pbenchmarks=true
+    //  - JVM system prop:  ./gradlew :lynglib:jvmTest -Dbenchmarks=true
+    //  - Environment var:  BENCHMARKS=true ./gradlew :lynglib:jvmTest
+    val benchmarksEnabled: Boolean = run {
+        val p = (project.findProperty("benchmarks") as String?)?.toBooleanStrictOrNull()
+        val s = System.getProperty("benchmarks")?.lowercase()?.let { it == "true" || it == "1" || it == "yes" }
+        val e = System.getenv("BENCHMARKS")?.lowercase()?.let { it == "true" || it == "1" || it == "yes" }
+        p ?: s ?: e ?: false
+    }
+
+    // Make the flag visible inside tests if they want to branch on it
+    systemProperty("LYNG_BENCHMARKS", benchmarksEnabled.toString())
+
+    if (!benchmarksEnabled) {
+        // Exclude all JVM tests whose class name ends with or contains BenchmarkTest
+        // This keeps CI fast and avoids noisy timing logs by default.
+        filter {
+            excludeTestsMatching("*BenchmarkTest")
+            // Also guard against alternative naming
+            excludeTestsMatching("*Bench*Test")
+            // Exclude A/B performance tests unless explicitly enabled
+            excludeTestsMatching("*ABTest")
+            // Exclude stress/perf soak tests
+            excludeTestsMatching("*Stress*Test")
+            // Exclude allocation profiling tests by default
+            excludeTestsMatching("*AllocationProfileTest")
+        }
+        logger.lifecycle("[tests] Benchmarks are DISABLED. To enable: -Pbenchmarks=true or -Dbenchmarks=true or set BENCHMARKS=true")
+    } else {
+        logger.lifecycle("[tests] Benchmarks are ENABLED: *BenchmarkTest will run")
+    }
+}
 
 //mavenPublishing {
 //    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)

lynglib/src/androidMain/kotlin/net/sergeych/lyng/ArgBuilderAndroid.kt

@@ -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 */ }
+}

lynglib/src/androidMain/kotlin/net/sergeych/lyng/PerfDefaults.android.kt

@@ -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
+}

lynglib/src/androidMain/kotlin/net/sergeych/lyng/ScopePoolAndroid.kt

@@ -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)
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ArgBuilder.kt

@@ -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()
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ArgRuntime.kt

@@ -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)

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ArgsDeclaration.kt

@@ -17,6 +17,7 @@
 
 package net.sergeych.lyng
 
+import net.sergeych.lyng.miniast.MiniTypeRef
 import net.sergeych.lyng.obj.Obj
 import net.sergeych.lyng.obj.ObjList
 import net.sergeych.lyng.obj.ObjRecord
@@ -56,72 +57,137 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
                 recordType = ObjRecord.Type.Argument)
         }
 
-        // will be used with last lambda arg fix
+        // Prepare positional args and parameter count, handle tail-block binding
         val callArgs: List<Obj>
         val paramsSize: Int
-
         if (arguments.tailBlockMode) {
+            // If last parameter is already assigned by a named argument, it's an error
+            val lastParam = params.last()
+            if (arguments.named.containsKey(lastParam.name))
+                scope.raiseIllegalArgument("trailing block cannot be used when the last parameter is already assigned by a named argument")
             paramsSize = params.size - 1
-            assign(params.last(), arguments.list.last())
+            assign(lastParam, arguments.list.last())
             callArgs = arguments.list.dropLast(1)
         } else {
             paramsSize = params.size
             callArgs = arguments.list
         }
 
-        suspend fun processHead(index: Int): Int {
+        // Compute which parameter indexes are inevitably covered by positional arguments
+        // based on the number of supplied positionals, defaults and ellipsis placement.
+        val coveredByPositional = BooleanArray(paramsSize)
+        run {
+            // Count required (non-default, non-ellipsis) params in head and in tail
+            var headRequired = 0
+            var tailRequired = 0
+            val ellipsisIdx = params.subList(0, paramsSize).indexOfFirst { it.isEllipsis }
+            if (ellipsisIdx >= 0) {
+                for (i in 0 until ellipsisIdx) if (!params[i].isEllipsis && params[i].defaultValue == null) headRequired++
+                for (i in paramsSize - 1 downTo ellipsisIdx + 1) if (params[i].defaultValue == null) tailRequired++
+            } else {
+                for (i in 0 until paramsSize) if (params[i].defaultValue == null) headRequired++
+            }
+            val P = callArgs.size
+            if (ellipsisIdx < 0) {
+                // No ellipsis: all positionals go to head until exhausted
+                val k = minOf(P, paramsSize)
+                for (i in 0 until k) coveredByPositional[i] = true
+            } else {
+                // With ellipsis: head takes min(P, headRequired) first
+                val headTake = minOf(P, headRequired)
+                for (i in 0 until headTake) coveredByPositional[i] = true
+                val remaining = P - headTake
+                // tail takes min(remaining, tailRequired) from the end
+                val tailTake = minOf(remaining, tailRequired)
+                var j = paramsSize - 1
+                var taken = 0
+                while (j > ellipsisIdx && taken < tailTake) {
+                    coveredByPositional[j] = true
+                    j--
+                    taken++
+                }
+            }
+        }
+
+        // Prepare arrays for named assignments
+        val assignedByName = BooleanArray(paramsSize)
+        val namedValues = arrayOfNulls<Obj>(paramsSize)
+        if (arguments.named.isNotEmpty()) {
+            for ((k, v) in arguments.named) {
+                val idx = params.subList(0, paramsSize).indexOfFirst { it.name == k }
+                if (idx < 0) scope.raiseIllegalArgument("unknown parameter '$k'")
+                if (params[idx].isEllipsis) scope.raiseIllegalArgument("ellipsis (variadic) parameter cannot be assigned by name: '$k'")
+                if (coveredByPositional[idx]) scope.raiseIllegalArgument("argument '$k' is already set by positional argument")
+                if (assignedByName[idx]) scope.raiseIllegalArgument("argument '$k' is already set")
+                assignedByName[idx] = true
+                namedValues[idx] = v
+            }
+        }
+
+        // Helper: assign head part, consuming from headPos; stop at ellipsis
+        suspend fun processHead(index: Int, headPos: Int): Pair<Int, Int> {
             var i = index
-            while (i != paramsSize) {
+            var hp = headPos
+            while (i < paramsSize) {
                 val a = params[i]
                 if (a.isEllipsis) break
-                val value = when {
+                if (assignedByName[i]) {
-                    i < callArgs.size -> callArgs[i]
+                    assign(a, namedValues[i]!!)
-                    a.defaultValue != null -> a.defaultValue.execute(scope)
+                } else {
-                    else -> {
+                    val value = if (hp < callArgs.size) callArgs[hp++]
-//                        println("callArgs: ${callArgs.joinToString()}")
+                    else a.defaultValue?.execute(scope)
-//                        println("tailBlockMode: ${arguments.tailBlockMode}")
+                        ?: scope.raiseIllegalArgument("too few arguments for the call")
-                        scope.raiseIllegalArgument("too few arguments for the call")
-                    }
-                }
                     assign(a, value)
+                }
                 i++
             }
-            return i
+            return i to hp
         }
 
-        suspend fun processTail(index: Int): Int {
+        // Helper: assign tail part from the end, consuming from tailPos; stop before ellipsis index
+        // Do not consume elements below headPosBound to avoid overlap with head consumption
+        suspend fun processTail(startExclusive: Int, tailStart: Int, headPosBound: Int): Int {
             var i = paramsSize - 1
-            var j = callArgs.size - 1
+            var tp = tailStart
-            while (i > index) {
+            while (i > startExclusive) {
                 val a = params[i]
                 if (a.isEllipsis) break
-                val value = when {
+                if (i < assignedByName.size && assignedByName[i]) {
-                    j >= index -> {
+                    assign(a, namedValues[i]!!)
-                        callArgs[j--]
+                } else {
-                    }
+                    val value = if (tp >= headPosBound) callArgs[tp--]
-
+                    else a.defaultValue?.execute(scope)
-                    a.defaultValue != null -> a.defaultValue.execute(scope)
+                        ?: scope.raiseIllegalArgument("too few arguments for the call")
-                    else -> scope.raiseIllegalArgument("too few arguments for the call")
-                }
                     assign(a, value)
+                }
                 i--
             }
-            return j
+            return tp
         }
 
-        fun processEllipsis(index: Int, toFromIndex: Int) {
+        fun processEllipsis(index: Int, headPos: Int, tailPos: Int) {
             val a = params[index]
-            val l = if (index > toFromIndex) ObjList()
+            val from = headPos
-            else ObjList(callArgs.subList(index, toFromIndex + 1).toMutableList())
+            val to = tailPos
+            val l = if (from > to) ObjList()
+            else ObjList(callArgs.subList(from, to + 1).toMutableList())
             assign(a, l)
         }
 
-        val leftIndex = processHead(0)
+        // Locate ellipsis index within considered parameters
-        if (leftIndex < paramsSize) {
+        val ellipsisIndex = params.subList(0, paramsSize).indexOfFirst { it.isEllipsis }
-            val end = processTail(leftIndex)
+
-            processEllipsis(leftIndex, end)
+        if (ellipsisIndex >= 0) {
+            // Assign head first to know how many positionals are consumed from the start
+            val (afterHead, headConsumedTo) = processHead(0, 0)
+            // Then assign tail consuming from the end down to headConsumedTo boundary
+            val tailConsumedFrom = processTail(ellipsisIndex, callArgs.size - 1, headConsumedTo)
+            // Assign ellipsis list from remaining positionals between headConsumedTo..tailConsumedFrom
+            processEllipsis(ellipsisIndex, headConsumedTo, tailConsumedFrom)
         } else {
-            if (leftIndex < callArgs.size)
+            // No ellipsis: assign head only; any leftover positionals → error
+            val (_, headConsumedTo) = processHead(0, 0)
+            if (headConsumedTo != callArgs.size)
                 scope.raiseIllegalArgument("too many arguments for the call")
         }
     }
@@ -135,6 +201,7 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
     data class Item(
         val name: String,
         val type: TypeDecl = TypeDecl.TypeAny,
+        val miniType: MiniTypeRef? = null,
         val pos: Pos = Pos.builtIn,
         val isEllipsis: Boolean = false,
         /**

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Arguments.kt

@@ -17,43 +17,227 @@
 
 package net.sergeych.lyng
 
-import net.sergeych.lyng.obj.Obj
+import net.sergeych.lyng.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,
+     val name: String? = null,
+ )
  
  suspend fun Collection<ParsedArgument>.toArguments(scope: Scope, tailBlockMode: Boolean): Arguments {
-    val list = mutableListOf<Obj>()
+     // Detect if we can use the fast path: no splats and no named args
+     if (PerfFlags.ARG_BUILDER) {
+         val limit = if (PerfFlags.ARG_SMALL_ARITY_12) 12 else 8
+         var hasSplatOrNamed = false
+         var count = 0
+         for (pa in this) {
+             if (pa.isSplat || pa.name != null) { hasSplatOrNamed = true; break }
+             count++
+             if (count > limit) break
+         }
+         if (!hasSplatOrNamed && 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
+         }
+     }
 
-    for (x in this) {
+     // General path: build positional list and named map, enforcing ordering rules
+     val positional: MutableList<Obj> = mutableListOf()
+     var named: MutableMap<String, Obj>? = null
+     var namedSeen = false
+     for ((idx, x) in this.withIndex()) {
+         if (x.name != null) {
+             // Named argument
+             if (named == null) named = linkedMapOf()
+             if (named.containsKey(x.name)) scope.raiseIllegalArgument("argument '${x.name}' is already set")
+             val v = x.value.execute(scope)
+             named[x.name] = v
+             namedSeen = true
+             continue
+         }
          val value = x.value.execute(scope)
          if (x.isSplat) {
              when {
+                 // IMPORTANT: handle ObjMap BEFORE generic Iterable to ensure map splats
+                 // are treated as named splats, not as positional iteration over entries
+                 value is ObjMap -> {
+                     if (named == null) named = linkedMapOf()
+                     for ((k, v) in value.map) {
+                         if (k !is ObjString) scope.raiseIllegalArgument("named splat expects a Map with string keys")
+                         val key = k.value
+                         if (named.containsKey(key)) scope.raiseIllegalArgument("argument '$key' is already set")
+                         named[key] = v
+                     }
+                     namedSeen = true
+                 }
                  value is ObjList -> {
-                    for (subitem in value.list) list.add(subitem)
+                     if (namedSeen) {
+                         // allow only if this is the very last positional which will be the trailing block; but
+                         // splat can never be a trailing block, so it's always illegal here
+                         scope.raiseIllegalArgument("positional splat cannot follow named arguments")
+                     }
+                     positional.addAll(value.list)
                  }
-
                  value.isInstanceOf(ObjIterable) -> {
+                     if (namedSeen) scope.raiseIllegalArgument("positional splat cannot follow named arguments")
                      val i = (value.invokeInstanceMethod(scope, "toList") as ObjList).list
-                    i.forEach { list.add(it) }
+                     positional.addAll(i)
                  }
-
                  else -> scope.raiseClassCastError("expected list of objects for splat argument")
              }
-        } else
+         } else {
-            list.add(value)
+             if (namedSeen) {
+                 // Allow exactly one positional after named only when it is the very last argument overall
+                 // and tailBlockMode is true (syntactic trailing block). Otherwise, forbid it.
+                 val isLast = idx == this.size - 1
+                 if (!(isLast && tailBlockMode))
+                     scope.raiseIllegalArgument("positional argument cannot follow named arguments")
              }
-    return Arguments(list,tailBlockMode)
+             positional.add(value)
+         }
+     }
+     val namedFinal = named ?: emptyMap()
+     return Arguments(positional, tailBlockMode, namedFinal)
   }
  
-data class Arguments(val list: List<Obj>, val tailBlockMode: Boolean = false) : List<Obj> by list {
+ data class Arguments(
+     val list: List<Obj>,
+     val tailBlockMode: Boolean = false,
+     val named: Map<String, Obj> = emptyMap(),
+ ) : 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().byValueCopy()
+         // Tiny micro-alloc win: avoid byValueCopy for immutable singletons
+         return when (val v = list.first()) {
+             ObjNull,
+             ObjTrue,
+             ObjFalse,
+            // Immutable scalars: safe to return directly
+            is ObjInt,
+            is ObjReal,
+            is ObjChar,
+            is ObjString -> v
+             else -> v.byValueCopy()
+         }
      }
  
      /**

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ClosureScope.kt

@@ -25,21 +25,48 @@ import net.sergeych.lyng.obj.ObjRecord
  * from [closureScope] with proper precedence
  */
 class ClosureScope(val callScope: Scope, val closureScope: Scope) :
-    Scope(callScope, callScope.args, thisObj = callScope.thisObj) {
+    // 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? {
-        // we take arguments from the callerScope, the rest
+        // Priority:
-        // from the closure.
+        // 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)
 
-        // note using super, not callScope, as arguments are assigned by the constructor
+        // First, prefer locals/arguments bound in this frame
-        // and are not assigned yet to vars in callScope self:
+        super.objects[name]?.let { return it }
-        super.objects[name]?.let {
+
-//            if( name == "predicate" ) {
+        // Prefer instance fields/methods declared on the captured receiver:
-//                println("predicate: ${it.type.isArgument}: ${it.value}")
+        // First, resolve real instance fields stored in the instance scope (constructor vars like `coll`, `factor`)
-//            }
+        (closureScope.thisObj as? net.sergeych.lyng.obj.ObjInstance)
-            if( it.type.isArgument ) return it
+            ?.instanceScope
-        }
+            ?.objects
-        return closureScope.get(name)
+            ?.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)
     }
 }
 

lynglib/src/commonMain/kotlin/net/sergeych/lyng/CompilerContext.kt

@@ -69,7 +69,15 @@ class CompilerContext(val tokens: List<Token>) {
         throw ScriptError(currentPos(), message)
     }
 
-    fun currentPos(): Pos = tokens[currentIndex].pos
+    fun currentPos(): Pos {
+        if (tokens.isEmpty()) return Pos.builtIn
+        val idx = when {
+            currentIndex < 0 -> 0
+            currentIndex >= tokens.size -> tokens.size - 1
+            else -> currentIndex
+        }
+        return tokens[idx].pos
+    }
 
     /**
      * If the next token is identifier `name`, skip it and return `true`.
@@ -164,6 +172,7 @@ class CompilerContext(val tokens: List<Token>) {
         }
     }
 
+    @Suppress("NOTHING_TO_INLINE")
     inline fun addBreak() {
         breakFound = true
     }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ListEntry.kt

@@ -17,10 +17,10 @@
 
 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()
 }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Parser.kt

@@ -20,10 +20,10 @@ 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)
@@ -67,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 == '>') {
                     pos.advance()
                     Token("=>", from, Token.Type.EQARROW)
-                }
+                } else if (currentChar == '~') {
-                else
+                    pos.advance()
+                    Token("=~", from, Token.Type.MATCH)
+                } else
                     Token("=", from, Token.Type.ASSIGN)
             }
 
@@ -81,12 +84,12 @@ private class Parser(fromPos: Pos) {
                 when (currentChar) {
                     '+' -> {
                         pos.advance()
-                        Token("+", from, Token.Type.PLUS2)
+                        Token("++", from, Token.Type.PLUS2)
                     }
 
                     '=' -> {
                         pos.advance()
-                        Token("+", from, Token.Type.PLUSASSIGN)
+                        Token("+=", from, Token.Type.PLUSASSIGN)
                     }
 
                     else ->
@@ -103,7 +106,7 @@ private class Parser(fromPos: Pos) {
 
                     '=' -> {
                         pos.advance()
-                        Token("-", from, Token.Type.MINUSASSIGN)
+                        Token("-=", from, Token.Type.MINUSASSIGN)
                     }
 
                     '>' -> {
@@ -126,17 +129,17 @@ private class Parser(fromPos: Pos) {
             '/' -> when (currentChar) {
                 '/' -> {
                     pos.advance()
-                    Token(loadToEndOfLine().trim(), from, Token.Type.SINLGE_LINE_COMMENT)
+                    val body = loadToEndOfLine()
+                    // Include the leading '//' and do not trim; keep exact lexeme (excluding preceding codepoint)
+                    Token("//" + body, from, Token.Type.SINLGE_LINE_COMMENT)
                 }
 
                 '*' -> {
                     pos.advance()
-                    Token(
+                    val content = loadTo("*/")
-                        loadTo("*/")?.trim()
+                        ?: throw ScriptError(from, "Unterminated multiline comment")
-                            ?: throw ScriptError(from, "Unterminated multiline comment"),
+                    // loadTo consumes the closing fragment, so we are already after */
-                        from,
+                    Token("/*" + content + "*/", from, Token.Type.MULTILINE_COMMENT)
-                        Token.Type.MULTILINE_COMMENT
-                    )
                 }
 
                 '=' -> {
@@ -188,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)
             }
@@ -196,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)
             }
@@ -227,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)
             }
@@ -247,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)
@@ -310,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()
@@ -324,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
@@ -380,7 +403,8 @@ private class Parser(fromPos: Pos) {
             // could be integer, also hex:
             if (currentChar == 'x' && p1 == "0") {
                 pos.advance()
-                Token(loadChars { it in hexDigits }, start, Token.Type.HEX).also {
+                val hex = loadChars { it in hexDigits }
+                Token(hex, start, Token.Type.HEX).also {
                     if (currentChar.isLetter())
                         raise("invalid hex literal")
                 }
@@ -404,8 +428,7 @@ private class Parser(fromPos: Pos) {
             if (l.isBlank()) {
                 sizes.add(-1)
                 ""
-            }
+            } else {
-            else {
                 val margin = leftMargin(l)
                 sizes += margin
                 " ".repeat(margin) + l.trim()
@@ -433,11 +456,30 @@ private class Parser(fromPos: Pos) {
                 '\\' -> {
                     pos.advance() ?: raise("unterminated string")
                     when (currentChar) {
-                        'n' -> {sb.append('\n'); pos.advance()}
+                        'n' -> {
-                        'r' -> {sb.append('\r'); pos.advance()}
+                            sb.append('\n'); pos.advance()
-                        't' -> {sb.append('\t'); pos.advance()}
+                        }
-                        '"' -> {sb.append('"'); pos.advance()}
+
-                        else -> sb.append('\\').append(currentChar)
+                        '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()
+                        }
                     }
                 }
 
@@ -500,11 +542,11 @@ private class Parser(fromPos: Pos) {
 
     private fun loadToEndOfLine(): String {
         val result = StringBuilder()
-        val l = pos.line
+        // Read characters up to but not including the line break
-        do {
+        while (!pos.end && pos.currentChar != '\n') {
             result.append(pos.currentChar)
             pos.advance()
-        } while (pos.line == l)
+        }
         return result.toString()
     }
 

lynglib/src/commonMain/kotlin/net/sergeych/lyng/PerfDefaults.kt

@@ -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
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/PerfFlags.kt

@@ -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
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/PerfProfiles.kt

@@ -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
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/PerfStats.kt

@@ -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
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Pos.kt

@@ -28,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
 
@@ -96,7 +98,4 @@ class MutablePos(private val from: Pos) {
 
     override fun toString() = "($line:$column)"
     
-    init {
-        if( lines[0].isEmpty()) advance()
-    }
 }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/RegexCache.kt

@@ -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()
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Scope.kt

@@ -21,6 +21,10 @@ 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.
@@ -36,14 +40,49 @@ import net.sergeych.lyng.pacman.ImportProvider
  *  - [ClosureScope] - scope used to apply a closure to some thisObj scope
  */
 open class Scope(
-    val parent: Scope?,
+    var parent: Scope?,
-    val args: Arguments = Arguments.EMPTY,
+    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,
@@ -131,25 +170,116 @@ open class Scope(
     open operator fun get(name: String): ObjRecord? =
         if (name == "this") thisObj.asReadonly
         else {
+            // 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)
-                ?: thisObj.objClass
+                // Finally, fallback to class members on thisObj
-                    .getInstanceMemberOrNull(name)
+                ?: thisObj.objClass.getInstanceMemberOrNull(name)
                 )
-//                ?.also {
-//                        if( name == "predicate") {
-//                            println("got predicate $it")
-//                        }
-//                }
         }
 
-    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,
@@ -158,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 {
@@ -227,11 +378,14 @@ open class Scope(
             parent?.currentImportProvider ?: throw IllegalStateException("this scope has no manager in the chain")
     }
 
-    val importManager by lazy { (currentImportProvider as? ImportManager)
+    val importManager by lazy {
-        ?: throw IllegalStateException("this scope has no manager in the chain (provided $currentImportProvider") }
+        (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}" }
+        val contents =
+            objects.entries.joinToString { "${if (it.value.isMutable) "var" else "val"} ${it.key}=${it.value.value}" }
         return "S[this=$thisObj $contents]"
     }
 
@@ -245,8 +399,6 @@ open class Scope(
             p = p.parent
         }
         println("--------------------")
-        ObjVoid
-
     }
 
     open fun applyClosure(closure: Scope): Scope = ClosureScope(this, closure)

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ScopePool.kt

@@ -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)
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt

@@ -19,6 +19,7 @@ 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
@@ -26,6 +27,7 @@ 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(),
@@ -157,8 +159,11 @@ 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") {
@@ -182,7 +187,7 @@ class Script(
                 catch( e: ExecutionError ) {
                     e.errorObject
                 }
-                catch (e: ScriptError) {
+                catch (_: ScriptError) {
                     ObjNull
                 }
                 result ?: raiseError(ObjAssertionFailedException(this,"Expected exception but nothing was thrown"))
@@ -213,8 +218,10 @@ class Script(
                 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)
@@ -241,6 +248,8 @@ class Script(
             addConst("CompletableDeferred", ObjCompletableDeferred.type)
             addConst("Mutex", ObjMutex.type)
 
+            addConst("Regex", ObjRegex.type)
+
             addFn("launch") {
                 val callable = requireOnlyArg<Statement>()
                 ObjDeferred(globalDefer {

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ScriptError.kt

@@ -26,7 +26,7 @@ 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
 )

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Source.kt

@@ -19,9 +19,13 @@ package net.sergeych.lyng
 
 import net.sergeych.lyng.obj.ObjString
 
-class Source(val fileName: String, text: String) {
+class Source(val fileName: String, val text: String) {
 
-    val lines = text.lines().map { it.trimEnd() }
+    // Preserve original text characters exactly; do not trim trailing spaces.
+    // Split by "\n" boundaries as the lexer models line breaks uniformly as a single newline
+    // between logical lines, regardless of original platform line endings.
+    // We intentionally do NOT trim line ends to keep columns accurate.
+    val lines: List<String> = text.split('\n')
 
     val objSourceName by lazy { ObjString(fileName) }
 

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Token.kt

@@ -30,18 +30,21 @@ data class Token(val value: String, val pos: Pos, val type: Type) {
 
     @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,

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Visibility.kt

@@ -23,3 +23,17 @@ enum class Visibility {
     @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))
+        }
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/binding/Binder.kt

@@ -0,0 +1,284 @@
+/*
+ * 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.
+ *
+ */
+
+/*
+ * Minimal binding for editor/highlighter: builds a simple scope tree from Mini-AST
+ * and binds identifier usages to declarations without type analysis.
+ */
+package net.sergeych.lyng.binding
+
+import net.sergeych.lyng.Source
+import net.sergeych.lyng.highlight.HighlightKind
+import net.sergeych.lyng.highlight.SimpleLyngHighlighter
+import net.sergeych.lyng.highlight.offsetOf
+import net.sergeych.lyng.miniast.MiniClassDecl
+import net.sergeych.lyng.miniast.MiniFunDecl
+import net.sergeych.lyng.miniast.MiniScript
+import net.sergeych.lyng.miniast.MiniValDecl
+
+enum class SymbolKind { Class, Enum, Function, Val, Var, Param }
+
+data class Symbol(
+    val id: Int,
+    val name: String,
+    val kind: SymbolKind,
+    val declStart: Int,
+    val declEnd: Int,
+    val containerId: Int?
+)
+
+data class Reference(val symbolId: Int, val start: Int, val end: Int)
+
+data class BindingSnapshot(
+    val symbols: List<Symbol>,
+    val references: List<Reference>
+)
+
+/**
+ * Very small binder that:
+ * - Registers symbols for top-level decls, function params, and local vals/vars inside function bodies.
+ * - Binds identifier tokens to the nearest matching symbol by lexical scope (function locals/params first, then top-level).
+ */
+object Binder {
+    fun bind(text: String, mini: MiniScript): BindingSnapshot {
+        val source = Source("<snippet>", text)
+        val highlighter = SimpleLyngHighlighter()
+        val spans = highlighter.highlight(text)
+
+        // 1) Collect symbols
+        val symbols = ArrayList<Symbol>()
+        var nextId = 1
+
+        // Helper to convert Pos to offsets
+        fun nameOffsets(startPos: net.sergeych.lyng.Pos, name: String): Pair<Int, Int> {
+            val s = source.offsetOf(startPos)
+            return s to (s + name.length)
+        }
+
+        // Class scopes to support fields and method resolution order
+        data class ClassScope(
+            val symId: Int,
+            val bodyStart: Int,
+            val bodyEnd: Int,
+            val fields: MutableList<Int>
+        )
+        val classes = ArrayList<ClassScope>()
+
+        // Map of function id to its local symbol ids and owning class (if method)
+        data class FnScope(
+            val id: Int,
+            val rangeStart: Int,
+            val rangeEnd: Int,
+            val locals: MutableList<Int>,
+            val classOwnerId: Int?
+        )
+        val functions = ArrayList<FnScope>()
+
+        // Index top-level for quick lookups
+        val topLevelByName = HashMap<String, MutableList<Int>>()
+
+        // Helper to find class that contains an offset (by body range)
+        fun classContaining(offset: Int): ClassScope? =
+            classes.asSequence()
+                .filter { it.bodyEnd > it.bodyStart && offset >= it.bodyStart && offset <= it.bodyEnd }
+                .maxByOrNull { it.bodyEnd - it.bodyStart }
+
+        // First pass (classes only): register classes so we can attach methods/fields
+        for (d in mini.declarations) if (d is MiniClassDecl) {
+            val (s, e) = nameOffsets(d.nameStart, d.name)
+            val sym = Symbol(nextId++, d.name, SymbolKind.Class, s, e, containerId = null)
+            symbols += sym
+            topLevelByName.getOrPut(d.name) { mutableListOf() }.add(sym.id)
+            // Prefer explicit body range; otherwise use the whole class declaration range
+            val bodyStart = d.bodyRange?.start?.let { source.offsetOf(it) } ?: source.offsetOf(d.range.start)
+            val bodyEnd = d.bodyRange?.end?.let { source.offsetOf(it) } ?: source.offsetOf(d.range.end)
+            classes += ClassScope(sym.id, bodyStart, bodyEnd, mutableListOf())
+            // Constructor fields (val/var in primary ctor)
+            for (cf in d.ctorFields) {
+                val fs = source.offsetOf(cf.nameStart)
+                val fe = fs + cf.name.length
+                val kind = if (cf.mutable) SymbolKind.Var else SymbolKind.Val
+                val fieldSym = Symbol(nextId++, cf.name, kind, fs, fe, containerId = sym.id)
+                symbols += fieldSym
+                classes.last().fields += fieldSym.id
+            }
+        }
+
+        // Second pass: functions and top-level/class vals/vars
+        for (d in mini.declarations) {
+            when (d) {
+                is MiniClassDecl -> { /* already processed in first pass */ }
+                is MiniFunDecl -> {
+                    val (s, e) = nameOffsets(d.nameStart, d.name)
+                    val ownerClass = classContaining(s)
+                    val sym = Symbol(nextId++, d.name, SymbolKind.Function, s, e, containerId = ownerClass?.symId)
+                    symbols += sym
+                    topLevelByName.getOrPut(d.name) { mutableListOf() }.add(sym.id)
+
+                    // Determine body range if present; otherwise, derive a conservative end at decl range end
+                    val bodyStart = d.body?.range?.start?.let { source.offsetOf(it) } ?: e
+                    val bodyEnd = d.body?.range?.end?.let { source.offsetOf(it) } ?: e
+                    val fnScope = FnScope(sym.id, bodyStart, bodyEnd, mutableListOf(), ownerClass?.symId)
+
+                    // Params
+                    for (p in d.params) {
+                        val ps = source.offsetOf(p.nameStart)
+                        val pe = ps + p.name.length
+                        val pk = SymbolKind.Param
+                        val paramSym = Symbol(nextId++, p.name, pk, ps, pe, containerId = sym.id)
+                        fnScope.locals += paramSym.id
+                        symbols += paramSym
+                    }
+                    functions += fnScope
+                }
+                is MiniValDecl -> {
+                    val (s, e) = nameOffsets(d.nameStart, d.name)
+                    val kind = if (d.mutable) SymbolKind.Var else SymbolKind.Val
+                    val ownerClass = classContaining(s)
+                    if (ownerClass != null) {
+                        // class field
+                        val fieldSym = Symbol(nextId++, d.name, kind, s, e, containerId = ownerClass.symId)
+                        symbols += fieldSym
+                        ownerClass.fields += fieldSym.id
+                    } else {
+                        val sym = Symbol(nextId++, d.name, kind, s, e, containerId = null)
+                        symbols += sym
+                        topLevelByName.getOrPut(d.name) { mutableListOf() }.add(sym.id)
+                    }
+                }
+            }
+        }
+
+        // Inject stdlib symbols into the top-level when imported, so calls like `filter {}` bind semantically.
+        run {
+            val importedModules = mini.imports.map { it.segments.joinToString(".") { s -> s.name } }
+            val hasStdlib = importedModules.any { it == "lyng.stdlib" || it.startsWith("lyng.stdlib.") }
+            if (hasStdlib) {
+                val stdFns = listOf(
+                    "filter", "map", "flatMap", "reduce", "fold", "take", "drop", "sorted",
+                    "groupBy", "count", "any", "all", "first", "last", "sum", "joinToString",
+                    // iterator trio often used implicitly/explicitly
+                    "iterator", "hasNext", "next"
+                )
+                for (name in stdFns) {
+                    val sym = Symbol(nextId++, name, SymbolKind.Function, 0, name.length, containerId = null)
+                    symbols += sym
+                    topLevelByName.getOrPut(name) { mutableListOf() }.add(sym.id)
+                }
+            }
+        }
+
+        // Second pass: attach local val/var declarations that fall inside any function body
+        for (d in mini.declarations) if (d is MiniValDecl) {
+            val (s, e) = nameOffsets(d.nameStart, d.name)
+            // Find containing function by body range that includes this declaration name
+            val containerFn = functions.asSequence()
+                .filter { it.rangeEnd > it.rangeStart && s >= it.rangeStart && s <= it.rangeEnd }
+                .maxByOrNull { it.rangeEnd - it.rangeStart }
+            if (containerFn != null) {
+                val fnSymId = containerFn.id
+                val kind = if (d.mutable) SymbolKind.Var else SymbolKind.Val
+                val localSym = Symbol(nextId++, d.name, kind, s, e, containerId = fnSymId)
+                symbols += localSym
+                containerFn.locals += localSym.id
+            }
+        }
+
+        // Build name -> symbol ids index per function (locals+params) and per class (fields) for faster resolution
+        data class Idx(val byName: Map<String, List<Int>>)
+        fun buildIndex(ids: List<Int>): Idx {
+            val map = HashMap<String, MutableList<Int>>()
+            for (id in ids) {
+                val s = symbols.first { it.id == id }
+                map.getOrPut(s.name) { mutableListOf() }.add(id)
+            }
+            return Idx(map)
+        }
+        val fnLocalIndex = HashMap<Int, Idx>() // key: function symbol id
+        for (fn in functions) fnLocalIndex[fn.id] = buildIndex(fn.locals)
+        val classFieldIndex = HashMap<Int, Idx>() // key: class symbol id
+        for (cls in classes) classFieldIndex[cls.symId] = buildIndex(cls.fields)
+
+        // Helper to find nearest match among candidates: pick the declaration with the smallest (usageStart - declStart) >= 0
+        fun chooseNearest(candidates: List<Int>, usageStart: Int): Int? {
+            var best: Int? = null
+            var bestDist = Int.MAX_VALUE
+            for (id in candidates) {
+                val s = symbols.first { it.id == id }
+                val dist = usageStart - s.declStart
+                if (dist >= 0 && dist < bestDist) {
+                    bestDist = dist; best = id
+                }
+            }
+            return best
+        }
+
+        // 2) Bind identifier usages to symbols
+        val references = ArrayList<Reference>()
+        for (span in spans) {
+            if (span.kind != HighlightKind.Identifier) continue
+            val start = span.range.start
+            val end = span.range.endExclusive
+            // Skip if this range equals a known declaration identifier range; those are styled separately
+            val isDecl = symbols.any { it.declStart == start && it.declEnd == end }
+            if (isDecl) continue
+
+            val name = text.substring(start, end)
+
+            // Prefer function-local matches: find the function whose body contains the usage
+            val inFn = functions.asSequence()
+                .filter { it.rangeEnd > it.rangeStart && start >= it.rangeStart && start <= it.rangeEnd }
+                .maxByOrNull { it.rangeEnd - it.rangeStart }
+            if (inFn != null) {
+                val idx = fnLocalIndex[inFn.id]
+                val locIds = idx?.byName?.get(name)
+                val hit = if (!locIds.isNullOrEmpty()) chooseNearest(locIds, start) else null
+                if (hit != null) {
+                    references += Reference(hit, start, end)
+                    continue
+                }
+
+                // If function belongs to a class, check class fields next
+                val ownerClassId = inFn.classOwnerId
+                if (ownerClassId != null) {
+                    val cidx = classFieldIndex[ownerClassId]
+                    val cfIds = cidx?.byName?.get(name)
+                    val cHit = if (!cfIds.isNullOrEmpty()) chooseNearest(cfIds, start) else null
+                    if (cHit != null) {
+                        references += Reference(cHit, start, end)
+                        continue
+                    }
+                }
+            }
+
+            // Else try top-level by name
+            val topIds = topLevelByName[name]
+            val topHit = if (!topIds.isNullOrEmpty()) chooseNearest(topIds, start) else null
+            if (topHit != null) {
+                references += Reference(topHit, start, end)
+                continue
+            }
+
+            // Fallback: choose the nearest declared symbol with this name regardless of scope (best effort)
+            val anyIds = symbols.filter { it.name == name }.map { it.id }
+            val anyHit = if (anyIds.isNotEmpty()) chooseNearest(anyIds, start) else null
+            if (anyHit != null) references += Reference(anyHit, start, end)
+        }
+
+        return BindingSnapshot(symbols, references)
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/highlight/HighlightApi.kt

@@ -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.
+ *
+ */
+
+/*
+ * Cross-platform highlighting API for the Lyng language.
+ */
+package net.sergeych.lyng.highlight
+
+/** Represents a half-open character range [start, endExclusive). */
+data class TextRange(val start: Int, val endExclusive: Int) {
+    init { require(start <= endExclusive) { "Invalid range: $start..$endExclusive" } }
+}
+
+/** Kinds of tokens for syntax highlighting. */
+enum class HighlightKind {
+    Keyword,
+    TypeName,
+    Identifier,
+    Number,
+    String,
+    Char,
+    Regex,
+    Comment,
+    Operator,
+    Punctuation,
+    Label,
+    Directive,
+    Error,
+}
+
+/** A highlighted span: character range and its semantic/lexical kind. */
+data class HighlightSpan(val range: TextRange, val kind: HighlightKind)
+
+/** Base interface for Lyng syntax highlighters. */
+interface LyngHighlighter {
+    /**
+     * Produce highlight spans for the given [text]. Spans are non-overlapping and
+     * ordered by start position. Adjacent spans of the same kind may be merged.
+     */
+    fun highlight(text: String): List<HighlightSpan>
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/highlight/SimpleLyngHighlighter.kt

@@ -0,0 +1,198 @@
+/*
+ * 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.highlight
+
+import net.sergeych.lyng.Pos
+import net.sergeych.lyng.Source
+import net.sergeych.lyng.Token.Type
+import net.sergeych.lyng.parseLyng
+
+/** Extension that converts a [Pos] (line/column) into absolute character offset in the [Source] text. */
+fun Source.offsetOf(pos: Pos): Int {
+    var off = 0
+    // Sum full preceding lines + one '\n' per line (lines[] were created by String.lines())
+    var i = 0
+    while (i < pos.line) {
+        off += lines[i].length + 1 // assume \n as separator
+        i++
+    }
+    off += pos.column
+    return off
+}
+
+private val reservedIdKeywords = setOf("constructor", "property")
+// Fallback textual keywords that might come from the lexer as ID in some contexts (e.g., snippets)
+private val fallbackKeywordIds = setOf(
+    // boolean operators
+    "and", "or", "not",
+    // declarations & modifiers
+    "fun", "fn", "class", "enum", "val", "var", "import", "package",
+    "private", "protected", "static", "open", "extern",
+    // control flow and misc
+    "if", "else", "when", "while", "do", "for", "try", "catch", "finally",
+    "throw", "return", "break", "continue", "this", "null", "true", "false"
+)
+
+/** Maps lexer token type (and sometimes value) to a [HighlightKind]. */
+private fun kindOf(type: Type, value: String): HighlightKind? = when (type) {
+    // identifiers and reserved ids
+    Type.ID -> when {
+        value in reservedIdKeywords -> HighlightKind.Keyword
+        value.lowercase() in fallbackKeywordIds -> HighlightKind.Keyword
+        else -> HighlightKind.Identifier
+    }
+
+    // numbers
+    Type.INT, Type.REAL, Type.HEX -> HighlightKind.Number
+
+    // text literals
+    Type.STRING, Type.STRING2 -> HighlightKind.String
+    Type.CHAR -> HighlightKind.Char
+    Type.REGEX -> HighlightKind.Regex
+
+    // comments
+    Type.SINLGE_LINE_COMMENT, Type.MULTILINE_COMMENT -> HighlightKind.Comment
+
+    // punctuation
+    Type.LPAREN, Type.RPAREN, Type.LBRACE, Type.RBRACE, Type.LBRACKET, Type.RBRACKET,
+    Type.COMMA, Type.SEMICOLON, Type.COLON -> HighlightKind.Punctuation
+
+    // textual control keywords
+    Type.IN, Type.NOTIN, Type.IS, Type.NOTIS, Type.AS, Type.ASNULL,
+    Type.AND, Type.OR, Type.NOT -> HighlightKind.Keyword
+
+    // labels / annotations
+    Type.LABEL, Type.ATLABEL -> HighlightKind.Label
+
+    // operators and symbolic constructs
+    Type.PLUS, Type.MINUS, Type.STAR, Type.SLASH, Type.PERCENT,
+    Type.ASSIGN, Type.PLUSASSIGN, Type.MINUSASSIGN, Type.STARASSIGN, Type.SLASHASSIGN, Type.PERCENTASSIGN,
+    Type.PLUS2, Type.MINUS2,
+    Type.EQ, Type.NEQ, Type.LT, Type.LTE, Type.GT, Type.GTE, Type.REF_EQ, Type.REF_NEQ, Type.MATCH, Type.NOTMATCH,
+    Type.DOT, Type.ARROW, Type.EQARROW, Type.QUESTION, Type.COLONCOLON,
+    Type.SHL, Type.SHR, Type.ELLIPSIS, Type.DOTDOT, Type.DOTDOTLT,
+    Type.NULL_COALESCE, Type.ELVIS, Type.NULL_COALESCE_INDEX, Type.NULL_COALESCE_INVOKE, Type.NULL_COALESCE_BLOCKINVOKE,
+    Type.SHUTTLE,
+    // bitwise textual operators (treat as operators for visuals)
+    Type.BITAND, Type.BITOR, Type.BITXOR, Type.BITNOT -> HighlightKind.Operator
+
+    // non-highlighting tokens
+    Type.NEWLINE, Type.EOF -> null
+}
+
+/** Merge contiguous spans of the same [HighlightKind] to reduce output size. */
+private fun mergeAdjacent(spans: List<HighlightSpan>): List<HighlightSpan> {
+    if (spans.isEmpty()) return spans
+    val out = ArrayList<HighlightSpan>(spans.size)
+    var prev = spans[0]
+    for (i in 1 until spans.size) {
+        val cur = spans[i]
+        if (cur.kind == prev.kind && cur.range.start == prev.range.endExclusive) {
+            prev = HighlightSpan(TextRange(prev.range.start, cur.range.endExclusive), prev.kind)
+        } else {
+            out += prev
+            prev = cur
+        }
+    }
+    out += prev
+    return out
+}
+
+/** Simple highlighter using the existing Lyng lexer (no incremental support yet). */
+class SimpleLyngHighlighter : LyngHighlighter {
+    override fun highlight(text: String): List<HighlightSpan> {
+        val src = Source("<snippet>", text)
+        val tokens = parseLyng(src)
+        val raw = ArrayList<HighlightSpan>(tokens.size)
+        fun adjustQuoteSpan(startOffset: Int, quoteChar: Char): TextRange {
+            var s = startOffset
+            if (s > 0 && text[s - 1] == quoteChar) s -= 1
+            var i = s + 1
+            while (i < text.length) {
+                val ch = text[i]
+                if (ch == '\\') {
+                    i += if (i + 1 < text.length) 2 else 1
+                    continue
+                }
+                if (ch == quoteChar) {
+                    return TextRange(s, i + 1)
+                }
+                i++
+            }
+            // Unterminated, highlight till end
+            return TextRange(s, text.length)
+        }
+
+        for (t in tokens) {
+            val k = kindOf(t.type, t.value) ?: continue
+            val start = src.offsetOf(t.pos)
+            val range = when (t.type) {
+                Type.STRING, Type.STRING2 -> adjustQuoteSpan(start, '"')
+                Type.CHAR -> adjustQuoteSpan(start, '\'')
+                Type.HEX -> {
+                    // Parser returns HEX token value without the leading "0x"; include it in highlight span
+                    val end = (start + 2 + t.value.length).coerceAtMost(text.length)
+                    TextRange(start, end)
+                }
+                else -> TextRange(start, (start + t.value.length).coerceAtMost(text.length))
+            }
+            if (range.endExclusive > range.start) raw += HighlightSpan(range, k)
+        }
+        // Adjust single-line comment spans to extend till EOL to compensate for lexer offset/length quirks
+        val adjusted = extendSingleLineCommentsToEol(text, raw)
+        // Spans are in order; merge adjacent of the same kind for compactness
+        return mergeAdjacent(adjusted)
+    }
+}
+
+/**
+ * Workaround/fix: ensure that single-line comment spans that start with `//` extend until the end of line.
+ * Drops any subsequent spans that would overlap the extended comment on the same line.
+ */
+private fun extendSingleLineCommentsToEol(
+    text: String,
+    spans: List<HighlightSpan>
+): List<HighlightSpan> {
+    if (spans.isEmpty()) return spans
+    val out = ArrayList<HighlightSpan>(spans.size)
+    var i = 0
+    while (i < spans.size) {
+        val s = spans[i]
+        if (s.kind == HighlightKind.Comment) {
+            // Check the original text actually has '//' at span start to avoid touching block comments
+            val start = s.range.start
+            val ahead = if (start in text.indices) text.substring(start, minOf(text.length, start + 2)) else ""
+            if (ahead == "//") {
+                // Extend to end of current line
+                val eol = text.indexOf('\n', start)
+                val newEnd = if (eol >= 0) eol else text.length
+                var j = i + 1
+                while (j < spans.size && spans[j].range.start < newEnd) {
+                    // Consume all overlapping spans on this line
+                    j++
+                }
+                out += HighlightSpan(TextRange(start, newEnd), s.kind)
+                i = j
+                continue
+            }
+        }
+        out += s
+        i++
+    }
+    return out
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/miniast/MiniAst.kt

@@ -0,0 +1,247 @@
+/*
+ * 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.
+ *
+ */
+
+/*
+ * Minimal, optional AST-like structures captured during parsing.
+ *
+ * These classes are lightweight and focused on editor features:
+ * - highlighting (precise ranges for ids/types)
+ * - documentation (raw doc text + summary)
+ * - basic autocomplete (visible names per scope)
+ *
+ * They are populated only when an optional MiniAstSink is provided to the compiler.
+ */
+
+package net.sergeych.lyng.miniast
+
+import net.sergeych.lyng.Pos
+
+// Ranges reuse existing Pos to stay consistent with compiler diagnostics
+data class MiniRange(val start: Pos, val end: Pos)
+
+// Simple documentation payload: raw text and a derived summary (first non-empty line)
+data class MiniDoc(
+    val range: MiniRange,
+    val raw: String,
+    val summary: String?,
+    val tags: Map<String, List<String>> = emptyMap()
+)
+
+sealed interface MiniNode { val range: MiniRange }
+
+// Identifier roles we can confidently assign at parse time without binding
+enum class IdRole {
+    DeclFun, DeclClass, DeclVal, DeclVar, Param, Label, TypeName, Ref
+}
+
+// Type references (syntax-level, position rich)
+sealed interface MiniTypeRef : MiniNode
+
+data class MiniTypeName(
+    override val range: MiniRange,
+    val segments: List<Segment>,
+    val nullable: Boolean
+) : MiniTypeRef {
+    data class Segment(val name: String, val range: MiniRange)
+}
+
+data class MiniGenericType(
+    override val range: MiniRange,
+    val base: MiniTypeRef,
+    val args: List<MiniTypeRef>,
+    val nullable: Boolean
+) : MiniTypeRef
+
+data class MiniFunctionType(
+    override val range: MiniRange,
+    val receiver: MiniTypeRef?,
+    val params: List<MiniTypeRef>,
+    val returnType: MiniTypeRef,
+    val nullable: Boolean
+) : MiniTypeRef
+
+data class MiniTypeVar(
+    override val range: MiniRange,
+    val name: String,
+    val nullable: Boolean
+) : MiniTypeRef
+
+// Script and declarations (lean subset; can be extended later)
+sealed interface MiniDecl : MiniNode {
+    val name: String
+    val doc: MiniDoc?
+    // Start position of the declaration name identifier in source; end can be derived as start + name.length
+    val nameStart: Pos
+}
+
+data class MiniScript(
+    override val range: MiniRange,
+    val declarations: MutableList<MiniDecl> = mutableListOf(),
+    val imports: MutableList<MiniImport> = mutableListOf(),
+    val statements: MutableList<MiniStmt> = mutableListOf()
+) : MiniNode
+
+data class MiniParam(
+    val name: String,
+    val type: MiniTypeRef?,
+    // Start position of parameter name in source
+    val nameStart: Pos
+)
+
+data class MiniFunDecl(
+    override val range: MiniRange,
+    override val name: String,
+    val params: List<MiniParam>,
+    val returnType: MiniTypeRef?,
+    val body: MiniBlock?,
+    override val doc: MiniDoc?,
+    override val nameStart: Pos
+) : MiniDecl
+
+data class MiniValDecl(
+    override val range: MiniRange,
+    override val name: String,
+    val mutable: Boolean,
+    val type: MiniTypeRef?,
+    val initRange: MiniRange?,
+    override val doc: MiniDoc?,
+    override val nameStart: Pos
+) : MiniDecl
+
+data class MiniClassDecl(
+    override val range: MiniRange,
+    override val name: String,
+    val bases: List<String>,
+    val bodyRange: MiniRange?,
+    val ctorFields: List<MiniCtorField> = emptyList(),
+    val classFields: List<MiniCtorField> = emptyList(),
+    override val doc: MiniDoc?,
+    override val nameStart: Pos
+) : MiniDecl
+
+data class MiniCtorField(
+    val name: String,
+    val mutable: Boolean,
+    val type: MiniTypeRef?,
+    val nameStart: Pos
+)
+
+sealed interface MiniStmt : MiniNode
+
+data class MiniBlock(
+    override val range: MiniRange,
+    val locals: MutableList<String> = mutableListOf()
+) : MiniStmt
+
+data class MiniIdentifier(
+    override val range: MiniRange,
+    val name: String,
+    val role: IdRole
+) : MiniNode
+
+// Streaming sink to collect mini-AST during parsing. Implementations may assemble a tree or process events.
+interface MiniAstSink {
+    fun onScriptStart(start: Pos) {}
+    fun onScriptEnd(end: Pos, script: MiniScript) {}
+
+    fun onDocCandidate(doc: MiniDoc) {}
+
+    fun onImport(node: MiniImport) {}
+    fun onFunDecl(node: MiniFunDecl) {}
+    fun onValDecl(node: MiniValDecl) {}
+    fun onClassDecl(node: MiniClassDecl) {}
+
+    fun onBlock(node: MiniBlock) {}
+    fun onIdentifier(node: MiniIdentifier) {}
+}
+
+// Tracer interface used by the compiler's type parser to simultaneously build
+// a MiniTypeRef (syntax-level) while the semantic TypeDecl is produced as usual.
+// Keep it extremely small for now: the current parser supports only simple
+// identifiers with optional nullable suffix. We can extend callbacks later for
+// generics and function types without breaking callers.
+interface MiniTypeTrace {
+    /**
+     * Report a simple (possibly qualified in the future) type name.
+     * @param segments ordered list of name parts with precise ranges
+     * @param nullable whether the trailing `?` was present
+     */
+    fun onSimpleName(segments: List<MiniTypeName.Segment>, nullable: Boolean)
+}
+
+// A simple builder that assembles a MiniScript tree from sink callbacks.
+class MiniAstBuilder : MiniAstSink {
+    private var currentScript: MiniScript? = null
+    private val blocks = ArrayDeque<MiniBlock>()
+    private var lastDoc: MiniDoc? = null
+    private var scriptDepth: Int = 0
+
+    fun build(): MiniScript? = currentScript
+
+    override fun onScriptStart(start: Pos) {
+        if (scriptDepth == 0) {
+            currentScript = MiniScript(MiniRange(start, start))
+        }
+        scriptDepth++
+    }
+
+    override fun onScriptEnd(end: Pos, script: MiniScript) {
+        scriptDepth = (scriptDepth - 1).coerceAtLeast(0)
+        if (scriptDepth == 0) {
+            // finalize root range only when closing the outermost script
+            currentScript = currentScript?.copy(range = MiniRange(currentScript!!.range.start, end))
+        }
+    }
+
+    override fun onDocCandidate(doc: MiniDoc) {
+        lastDoc = doc
+    }
+
+    override fun onImport(node: MiniImport) {
+        currentScript?.imports?.add(node)
+    }
+
+    override fun onFunDecl(node: MiniFunDecl) {
+        val attach = node.copy(doc = node.doc ?: lastDoc)
+        currentScript?.declarations?.add(attach)
+        lastDoc = null
+    }
+
+    override fun onValDecl(node: MiniValDecl) {
+        val attach = node.copy(doc = node.doc ?: lastDoc)
+        currentScript?.declarations?.add(attach)
+        lastDoc = null
+    }
+
+    override fun onClassDecl(node: MiniClassDecl) {
+        val attach = node.copy(doc = node.doc ?: lastDoc)
+        currentScript?.declarations?.add(attach)
+        lastDoc = null
+    }
+
+    override fun onBlock(node: MiniBlock) {
+        blocks.addLast(node)
+    }
+}
+
+// Import statement representation for highlighting and docs
+data class MiniImport(
+    override val range: MiniRange,
+    val segments: List<Segment>
+) : MiniNode {
+    data class Segment(val name: String, val range: MiniRange)
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/Accessor.kt

@@ -15,7 +15,6 @@
  *
  */
 
-
 package net.sergeych.lyng.obj
 
 import net.sergeych.lyng.Compiler
@@ -26,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.
+ * Final migration shim: make `Accessor` an alias to `ObjRef`.
+ * This preserves source compatibility while removing lambda-based indirection.
  */
-    fun setter(pos: Pos) = setterOrNull ?: throw ScriptError(pos, "can't assign value")
+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)
 }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/Obj.kt

@@ -17,19 +17,12 @@
 
 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.mptools.CachedExpression
-import net.sergeych.synctools.ProtectedOp
-import net.sergeych.synctools.withLock
-import kotlin.contracts.ExperimentalContracts
 
 open class Obj {
 
@@ -43,12 +36,12 @@ 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 suspend fun inspect(scope: Scope): String = toString(scope).value
 
@@ -87,13 +80,26 @@ open class Obj {
         args: Arguments = Arguments.EMPTY,
         onNotFoundResult: (() -> Obj?)? = null
     ): Obj {
-        return objClass.getInstanceMemberOrNull(name)?.value?.invoke(
+        val rec = objClass.getInstanceMemberOrNull(name)
-            scope,
+        if (rec != null) {
-            this,
+            val decl = rec.declaringClass ?: objClass.findDeclaringClassOf(name)
-            args
+            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"
             )
-            ?: onNotFoundResult?.invoke()
-            ?: scope.raiseSymbolNotFound(name)
     }
 
     open suspend fun getInstanceMethod(
@@ -104,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
 
@@ -131,7 +137,7 @@ open class Obj {
      * @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
      */
-    suspend open fun toString(scope: Scope,calledFromLyng: Boolean=false): ObjString {
+    open suspend fun toString(scope: Scope,calledFromLyng: Boolean=false): ObjString {
         return if (this is ObjString) this
         else if( !calledFromLyng ) {
             invokeInstanceMethod(scope, "toString") {
@@ -182,6 +188,39 @@ 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
@@ -228,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
@@ -245,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")
     }
 
@@ -264,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
@@ -277,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
@@ -285,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) }
@@ -294,17 +350,32 @@ 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 {
-        val scope = parent.copy(newThisObj = this, args = parent.args)
+        // 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 {
@@ -319,7 +390,7 @@ open class Obj {
             }
             // utilities
             addFn("let") {
-                args.firstAndOnly().callOn(copy(Arguments(thisObj)))
+                args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
             }
             addFn("apply") {
                 val body = args.firstAndOnly()
@@ -331,7 +402,7 @@ open class Obj {
                 thisObj
             }
             addFn("also") {
-                args.firstAndOnly().callOn(copy(Arguments(thisObj)))
+                args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
                 thisObj
             }
             addFn("run") {
@@ -351,6 +422,7 @@ open class Obj {
         }
 
 
+        @Suppress("NOTHING_TO_INLINE")
         inline fun from(obj: Any?): Obj {
             @Suppress("UNCHECKED_CAST")
             return when (obj) {
@@ -500,195 +572,4 @@ data class ObjNamespace(val name: String) : Obj() {
     }
 }
 
-/**
- * note on [getStackTrace]. If [useStackTrace] is not null, it is used instead. Otherwise, it is calculated
- * from the current scope which is treated as exception scope. It is used to restore serialized
- * exception with stack trace; the scope of the de-serialized 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 cls = 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()) {
-                    result.list += cls.callWithArgs(
-                        scope,
-                        pos.source.objSourceName,
-                        ObjInt(pos.line.toLong()),
-                        ObjInt(pos.column.toLong()),
-                        ObjString(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("Throwable").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",
-                "NoSuchElementException",
-                "IllegalAssignmentException",
-                "SymbolNotDefinedException",
-                "IterationEndException",
-                "AccessException",
-                "UnknownException",
-                "NotFoundException"
-            )) {
-                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)
-
-class ObjNotFoundException(scope: Scope, message: String = "not found") :
-    ObjException("NotFoundException", scope, message)

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjBitBuffer.kt

@@ -35,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") {

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjBuffer.kt

@@ -62,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 {

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjClass.kt

@@ -21,6 +21,9 @@ 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(
@@ -28,11 +31,21 @@ 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.
      *
@@ -43,10 +56,77 @@ open class ObjClass(
      */
     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 {
+        buildSet {
-            listOf(it) + it.allParentsSet
+            fun collect(c: ObjClass) {
-        }.toMutableSet()
+                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 }
 
@@ -61,15 +141,101 @@ open class ObjClass(
 
     override suspend fun callOn(scope: Scope): Obj {
         val instance = ObjInstance(this)
-        instance.instanceScope = scope.copy(newThisObj = instance, args = scope.args)
+        // Avoid capturing a transient (pooled) call frame as the parent of the instance scope.
-        if (instanceConstructor != null) {
+        // Bind instance scope to the caller's parent chain directly so name resolution (e.g., stdlib like sqrt)
-            instanceConstructor!!.execute(instance.instanceScope)
+        // 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.copy(Arguments(*plainArgs)))
+        return callOn(scope.createChildScope(Arguments(*plainArgs)))
     }
 
 
@@ -80,10 +246,14 @@ open class ObjClass(
         visibility: Visibility = Visibility.Public,
         pos: Pos = Pos.builtIn
     ) {
-        val existing = members[name] ?: allParentsSet.firstNotNullOfOrNull { it.members[name] }
+        // Allow overriding ancestors: only prevent redefinition if THIS class already defines an immutable member
-        if (existing?.isMutable == false)
+        val existingInSelf = members[name]
-            throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
+        if (existingInSelf != null && existingInSelf.isMutable == false)
-        members[name] = ObjRecord(initialValue, isMutable, visibility)
+            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 {
@@ -103,10 +273,18 @@ open class ObjClass(
         if (existing != null)
             throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
         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) {
+    fun addFn(
-        createField(name, statement { code() }, isOpen)
+        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)
@@ -120,15 +298,46 @@ 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 }
+        // Unified traversal in strict C3 order: self, then each ancestor, checking members before classScope
-        allParentsSet.forEach { parent -> parent.getInstanceMemberOrNull(name)?.let { return it } }
+        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 {
         classScope?.objects?.get(name)?.let {
             if (it.visibility.isPublic) return it

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjDeferred.kt

@@ -37,7 +37,9 @@ open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
                 thisAs<ObjDeferred>().deferred.isCompleted.toObj()
             }
             addFn("isActive") {
-                thisAs<ObjDeferred>().deferred.isActive.toObj()
+                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()

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjDynamic.kt

@@ -47,13 +47,20 @@ class ObjDynamicContext(val delegate: ObjDynamic) : Obj() {
     }
 }
 
-class ObjDynamic : Obj() {
+/**
+ * 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() {
 
-    internal var readCallback: Statement? = null
+    override val objClass: ObjClass = type
-    internal var writeCallback: Statement? = null
 
+    /**
+     * 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.copy(Arguments(ObjString(name))))?.let {
+        return readCallback?.execute(scope.createChildScope(Arguments(ObjString(name))))?.let {
             if (writeCallback != null)
                 it.asMutable
             else
@@ -62,21 +69,53 @@ class ObjDynamic : Obj() {
             ?: 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.copy(Arguments(ObjString(name), newValue)))
+        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.copy(newThisObj = context))
+            builder.execute(scope.createChildScope(newThisObj = context))
             return delegate
         }
 
-        val type = object : ObjClass("Delegate") {}
+        val type = object : ObjClass("Delegate") {}.apply {
+//            addClassConst("IndexGetName", operatorGetName)
+        }
     }
 
 }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjException.kt

@@ -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)

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjFlow.kt

@@ -43,11 +43,18 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
                     if (!channel.isClosedForSend)
                         channel.send(data)
                     else
+                        // Flow consumer is no longer collecting; signal producer to stop
                         throw ScriptFlowIsNoMoreCollected()
                 } catch (x: Exception) {
-                    if (x !is CancellationException)
+                    // Any failure to send (including closed channel) should gracefully stop the producer.
-                        x.printStackTrace()
+                    // Do not print stack traces here to keep test output clean on JVM.
+                    if (x is CancellationException) {
+                        // Cancellation is a normal control-flow event
                         throw ScriptFlowIsNoMoreCollected()
+                    } else {
+                        // Treat other send failures as normal flow termination as well
+                        throw ScriptFlowIsNoMoreCollected()
+                    }
                 }
                 ObjVoid
             }
@@ -58,15 +65,15 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
 private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChannel<Obj> {
     val channel = Channel<Obj>(Channel.RENDEZVOUS)
     val builder = ObjFlowBuilder(channel)
-    val builderScope = scope.copy(newThisObj = builder)
+    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()
+            // Suppress stack traces in background producer to avoid noisy stderr during tests.
+            // If needed, consider routing to a logger in the future.
         }
         channel.close()
     }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjInstance.kt

@@ -19,6 +19,7 @@ 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
@@ -28,40 +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 {
+        // Direct (unmangled) lookup first
-            if (it.visibility.isPublic)
+        instanceScope[name]?.let {
-                it
+            val decl = it.declaringClass ?: objClass.findDeclaringClassOf(name)
-            else
+            // When execution passes through suspension points (e.g., withLock),
-                scope.raiseError(ObjAccessException(scope, "can't access non-public field $name"))
+            // 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)
+            val decl = f.declaringClass ?: objClass.findDeclaringClassOf(name)
-                ObjIllegalAssignmentException(scope, "can't assign to non-public field $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 {
+        instanceScope[name]?.let { rec ->
-            if (it.visibility.isPublic)
+            val decl = rec.declaringClass ?: objClass.findDeclaringClassOf(name)
-                it.value.invoke(
+            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)
-            else
+            } finally {
-                scope.raiseError(ObjAccessException(scope, "can't invoke non-public method $name"))
+                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(",")
@@ -121,3 +222,116 @@ 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()
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjInstanceClass.kt

@@ -25,14 +25,14 @@ 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) {
+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)
         val actualSize = constructorMeta?.params?.size ?: 0
         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") { ObjVoid }
@@ -41,7 +41,6 @@ class ObjInstanceClass(val name: String) : ObjClass(name) {
 
     init {
         addFn("toString", true) {
-            println("-------------- tos! --------------")
             ObjString(thisObj.toString())
         }
     }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjInt.kt

@@ -118,6 +118,29 @@ class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Nu
         return ObjInt(-value)
     }
 
+    // Bitwise operations
+    override suspend fun bitAnd(scope: Scope, other: Obj): Obj =
+        if (other is ObjInt) ObjInt(this.value and other.value)
+        else scope.raiseIllegalArgument("bitwise and '&' requires Int, got ${other.objClass.className}")
+
+    override suspend fun bitOr(scope: Scope, other: Obj): Obj =
+        if (other is ObjInt) ObjInt(this.value or other.value)
+        else scope.raiseIllegalArgument("bitwise or '|' requires Int, got ${other.objClass.className}")
+
+    override suspend fun bitXor(scope: Scope, other: Obj): Obj =
+        if (other is ObjInt) ObjInt(this.value xor other.value)
+        else scope.raiseIllegalArgument("bitwise xor '^' requires Int, got ${other.objClass.className}")
+
+    override suspend fun shl(scope: Scope, other: Obj): Obj =
+        if (other is ObjInt) ObjInt(this.value shl (other.value.toInt() and 63))
+        else scope.raiseIllegalArgument("shift left '<<' requires Int, got ${other.objClass.className}")
+
+    override suspend fun shr(scope: Scope, other: Obj): Obj =
+        if (other is ObjInt) ObjInt(this.value shr (other.value.toInt() and 63))
+        else scope.raiseIllegalArgument("shift right '>>' requires Int, got ${other.objClass.className}")
+
+    override suspend fun bitNot(scope: Scope): Obj = ObjInt(this.value.inv())
+
     override suspend fun lynonType(): LynonType = when (value) {
         0L -> LynonType.Int0
         else -> {

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjIterable.kt

@@ -93,7 +93,7 @@ val ObjIterable by lazy {
             val fn = requiredArg<Statement>(0)
             while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
                 val x = it.invokeInstanceMethod(this, "next")
-                fn.execute(this.copy(Arguments(listOf(x))))
+                fn.execute(this.createChildScope(Arguments(listOf(x))))
             }
             ObjVoid
         }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjKotlinIterator.kt

@@ -87,13 +87,25 @@ suspend fun Obj.enumerate(scope: Scope, callback: suspend (Obj) -> Boolean) {
     val hasNext = iterator.getInstanceMethod(scope, "hasNext")
     val next = iterator.getInstanceMethod(scope, "next")
     var closeIt = false
+    try {
         while (hasNext.invoke(scope, iterator).toBool()) {
             val nextValue = next.invoke(scope, iterator)
-        if (!callback(nextValue)) {
+            val shouldContinue = try {
+                callback(nextValue)
+            } catch (e: Exception) {
+                // iteration aborted due to exception in callback
+                closeIt = true
+                throw e
+            }
+            if (!shouldContinue) {
                 closeIt = true
                 break
             }
         }
-    if (closeIt)
+    } finally {
+        if (closeIt) {
+            // Best-effort cancel on premature termination
             iterator.invokeInstanceMethod(scope, "cancelIteration") { ObjVoid }
         }
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjList.kt

@@ -118,6 +118,19 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
     }
 
     override suspend fun contains(scope: Scope, other: Obj): Boolean {
+        if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) {
+            // Fast path: int membership in a list of ints (common case in benches)
+            if (other is ObjInt) {
+                var i = 0
+                val sz = list.size
+                while (i < sz) {
+                    val v = list[i]
+                    if (v is ObjInt && v.value == other.value) return true
+                    i++
+                }
+                return false
+            }
+        }
         return list.contains(other)
     }
 
@@ -273,6 +286,115 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
                 thisAs<ObjList>().list.shuffle()
                 ObjVoid
             }
+            addFn("sum") {
+                val self = thisAs<ObjList>()
+                val l = self.list
+                if (l.isEmpty()) return@addFn ObjNull
+                if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) {
+                    // Fast path: all ints → accumulate as long
+                    var i = 0
+                    var acc: Long = 0
+                    while (i < l.size) {
+                        val v = l[i]
+                        if (v is ObjInt) {
+                            acc += v.value
+                            i++
+                        } else {
+                            // Fallback to generic dynamic '+' accumulation starting from current acc
+                            var res: Obj = ObjInt(acc)
+                            while (i < l.size) {
+                                res = res.plus(this, l[i])
+                                i++
+                            }
+                            return@addFn res
+                        }
+                    }
+                    return@addFn ObjInt(acc)
+                }
+                // Generic path: dynamic '+' starting from first element
+                var res: Obj = l[0]
+                var k = 1
+                while (k < l.size) {
+                    res = res.plus(this, l[k])
+                    k++
+                }
+                res
+            }
+            addFn("min") {
+                val l = thisAs<ObjList>().list
+                if (l.isEmpty()) return@addFn ObjNull
+                if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) {
+                    var i = 0
+                    var hasOnlyInts = true
+                    var minVal: Long = Long.MAX_VALUE
+                    while (i < l.size) {
+                        val v = l[i]
+                        if (v is ObjInt) {
+                            if (v.value < minVal) minVal = v.value
+                        } else {
+                            hasOnlyInts = false
+                            break
+                        }
+                        i++
+                    }
+                    if (hasOnlyInts) return@addFn ObjInt(minVal)
+                }
+                var res: Obj = l[0]
+                var i = 1
+                while (i < l.size) {
+                    val v = l[i]
+                    if (v.compareTo(this, res) < 0) res = v
+                    i++
+                }
+                res
+            }
+            addFn("max") {
+                val l = thisAs<ObjList>().list
+                if (l.isEmpty()) return@addFn ObjNull
+                if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) {
+                    var i = 0
+                    var hasOnlyInts = true
+                    var maxVal: Long = Long.MIN_VALUE
+                    while (i < l.size) {
+                        val v = l[i]
+                        if (v is ObjInt) {
+                            if (v.value > maxVal) maxVal = v.value
+                        } else {
+                            hasOnlyInts = false
+                            break
+                        }
+                        i++
+                    }
+                    if (hasOnlyInts) return@addFn ObjInt(maxVal)
+                }
+                var res: Obj = l[0]
+                var i = 1
+                while (i < l.size) {
+                    val v = l[i]
+                    if (v.compareTo(this, res) > 0) res = v
+                    i++
+                }
+                res
+            }
+            addFn("indexOf") {
+                val l = thisAs<ObjList>().list
+                val needle = args.firstAndOnly()
+                if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS && needle is ObjInt) {
+                    var i = 0
+                    while (i < l.size) {
+                        val v = l[i]
+                        if (v is ObjInt && v.value == needle.value) return@addFn ObjInt(i.toLong())
+                        i++
+                    }
+                    return@addFn ObjInt((-1).toLong())
+                }
+                var i = 0
+                while (i < l.size) {
+                    if (l[i].compareTo(this, needle) == 0) return@addFn ObjInt(i.toLong())
+                    i++
+                }
+                ObjInt((-1).toLong())
+            }
         }
     }
 }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjMap.kt

@@ -75,6 +75,12 @@ class ObjMapEntry(val key: Obj, val value: Obj) : Obj() {
             addFn("size") { 2.toObj() }
         }
     }
+
+    override suspend fun plus(scope: Scope, other: Obj): Obj {
+        // Build a new map starting from this entry, then merge `other`.
+        val result = ObjMap(mutableMapOf(key to value))
+        return result.plus(scope, other)
+    }
 }
 
 class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
@@ -96,7 +102,22 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
         if( other is ObjMap && other.map == map) return 0
         return -1
     }
-    override fun toString(): String = map.toString()
+
+    override suspend fun toString(scope: Scope, calledFromLyng: Boolean): ObjString {
+        val reusult = buildString {
+            append("Map(")
+            var first = true
+            for( (k,v) in map) {
+                if( !first ) append(",")
+                append(k.inspect(scope))
+                append(" => ")
+                append(v.toString(scope).value)
+                first = false
+            }
+            append(")")
+        }
+        return ObjString(reusult)
+    }
 
     override fun hashCode(): Int {
         return map.hashCode()
@@ -187,4 +208,44 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
             }
         }
     }
+
+    // Merge operations
+    override suspend fun plus(scope: Scope, other: Obj): Obj {
+        val result = ObjMap(map.toMutableMap())
+        result.mergeIn(scope, other)
+        return result
+    }
+
+    override suspend fun plusAssign(scope: Scope, other: Obj): Obj {
+        mergeIn(scope, other)
+        return this
+    }
+
+    private suspend fun mergeIn(scope: Scope, other: Obj) {
+        when (other) {
+            is ObjMap -> {
+                // Rightmost wins: copy all entries from `other` over existing ones
+                for ((k, v) in other.map) {
+                    val key = k as? ObjString ?: scope.raiseIllegalArgument("map merge expects string keys; got $k")
+                    map[key] = v
+                }
+            }
+            is ObjMapEntry -> {
+                val key = other.key as? ObjString ?: scope.raiseIllegalArgument("map merge expects string keys; got ${other.key}")
+                map[key] = other.value
+            }
+            is ObjList -> {
+                // Treat as list of map entries
+                for (e in other.list) {
+                    val entry = when (e) {
+                        is ObjMapEntry -> e
+                        else -> scope.raiseIllegalArgument("map can only be merged with MapEntry elements; got $e")
+                    }
+                    val key = entry.key as? ObjString ?: scope.raiseIllegalArgument("map merge expects string keys; got ${entry.key}")
+                    map[key] = entry.value
+                }
+            }
+            else -> scope.raiseIllegalArgument("map can only be merged with Map, MapEntry, or List<MapEntry>")
+        }
+    }
 }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjMutex.kt

@@ -33,6 +33,9 @@ class ObjMutex(val mutex: Mutex): Obj() {
         }.apply {
             addFn("withLock") {
                 val f = requiredArg<Statement>(0)
+                // Execute user lambda directly in the current scope to preserve the active scope
+                // ancestry across suspension points. The lambda still constructs a ClosureScope
+                // on top of this frame, and parseLambdaExpression sets skipScopeCreation for its body.
                 thisAs<ObjMutex>().mutex.withLock { f.execute(this) }
             }
         }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjRange.kt

@@ -161,6 +161,18 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
             }
             addFn("iterator") {
                 val self = thisAs<ObjRange>()
+                if (net.sergeych.lyng.PerfFlags.RANGE_FAST_ITER) {
+                    val s = self.start
+                    val e = self.end
+                    if (s is ObjInt && e is ObjInt) {
+                        val start = s.value.toInt()
+                        val endExclusive = (if (self.isEndInclusive) e.value.toInt() + 1 else e.value.toInt())
+                        // Only for ascending simple ranges; fall back otherwise
+                        if (start <= endExclusive) {
+                            return@addFn ObjFastIntRangeIterator(start, endExclusive)
+                        }
+                    }
+                }
                 ObjRangeIterator(self).apply { init() }
             }
         }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjRangeIterator.kt

@@ -17,6 +17,7 @@
 
 package net.sergeych.lyng.obj
 
+import net.sergeych.lyng.PerfFlags
 import net.sergeych.lyng.Scope
 
 class ObjRangeIterator(val self: ObjRange) : Obj() {
@@ -66,3 +67,27 @@ class ObjRangeIterator(val self: ObjRange) : Obj() {
         }
     }
 }
+
+/**
+ * Fast iterator for simple integer ranges (step +1). Returned only when
+ * [PerfFlags.RANGE_FAST_ITER] is enabled and the range is an ascending int range.
+ */
+class ObjFastIntRangeIterator(private val start: Int, private val endExclusive: Int) : Obj() {
+
+    private var cur: Int = start
+
+    override val objClass: ObjClass = type
+
+    fun hasNext(): Boolean = cur < endExclusive
+
+    fun next(scope: Scope): Obj =
+        if (cur < endExclusive) ObjInt(cur++.toLong())
+        else scope.raiseError(ObjIterationFinishedException(scope))
+
+    companion object {
+        val type = ObjClass("FastIntRangeIterator", ObjIterator).apply {
+            addFn("hasNext") { thisAs<ObjFastIntRangeIterator>().hasNext().toObj() }
+            addFn("next") { thisAs<ObjFastIntRangeIterator>().next(this) }
+        }
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjReal.kt

@@ -41,7 +41,19 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
         return value.compareTo(other.doubleValue)
     }
 
-    override fun toString(): String = value.toString()
+    override fun toString(): String {
+        // Normalize scientific notation to match tests across platforms.
+        // Kotlin/JVM prints 1e-6 as "1.0E-6" by default; tests accept "1E-6" (or a plain decimal).
+        val s = value.toString()
+        val ePos = s.indexOf('E').let { if (it >= 0) it else s.indexOf('e') }
+        if (ePos >= 0) {
+            val mantissa = s.substring(0, ePos)
+            val exponent = s.substring(ePos + 1) // skip the 'E'/'e'
+            val mantissaNorm = if (mantissa.endsWith(".0")) mantissa.dropLast(2) else mantissa
+            return mantissaNorm + "E" + exponent
+        }
+        return s
+    }
 
     override fun hashCode(): Int {
         return value.hashCode()

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjRecord.kt

@@ -27,6 +27,8 @@ data class ObjRecord(
     var value: Obj,
     val isMutable: Boolean,
     val visibility: Visibility = Visibility.Public,
+    /** If non-null, denotes the class that declared this member (field/method). */
+    val declaringClass: ObjClass? = null,
     var importedFrom: Scope? = null,
     val isTransient: Boolean = false,
     val type: Type = Type.Other

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjRegex.kt

@@ -0,0 +1,116 @@
+/*
+ * 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.PerfFlags
+import net.sergeych.lyng.RegexCache
+import net.sergeych.lyng.Scope
+
+class ObjRegex(val regex: Regex) : Obj() {
+    override val objClass = type
+
+    override suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
+        return regex.find(other.cast<ObjString>(scope).value)?.let {
+            scope.addOrUpdateItem("$~", ObjRegexMatch(it))
+            ObjTrue
+        } ?: ObjFalse
+    }
+
+    fun find(s: ObjString): Obj =
+        regex.find(s.value)?.let { ObjRegexMatch(it) } ?: ObjNull
+
+    companion object {
+        val type by lazy {
+            object : ObjClass("Regex") {
+                override suspend fun callOn(scope: Scope): Obj {
+                    val pattern = scope.requireOnlyArg<ObjString>().value
+                    val re = if (PerfFlags.REGEX_CACHE) RegexCache.get(pattern) else pattern.toRegex()
+                    return ObjRegex(re)
+                }
+            }.apply {
+                addFn("matches") {
+                    ObjBool(args.firstAndOnly().toString().matches(thisAs<ObjRegex>().regex))
+                }
+                addFn("find") {
+                    thisAs<ObjRegex>().find(requireOnlyArg<ObjString>())
+                }
+                addFn("findAll") {
+                    val s = requireOnlyArg<ObjString>().value
+                    ObjList(thisAs<ObjRegex>().regex.findAll(s).map { ObjRegexMatch(it) }.toMutableList())
+                }
+            }
+        }
+    }
+}
+
+class ObjRegexMatch(val match: MatchResult) : Obj() {
+    override val objClass = type
+
+    val objGroups: ObjList by lazy {
+        // Use groupValues so that index 0 is the whole match and subsequent indices are capturing groups,
+        // which matches the language/tests expectation for `$~[i]`.
+        ObjList(
+            match.groupValues.map { ObjString(it) as Obj }.toMutableList()
+        )
+    }
+
+    val objValue by lazy { ObjString(match.value) }
+
+    val objRange: ObjRange by lazy {
+        val r = match.range
+
+        ObjRange(
+            ObjInt(r.first.toLong()),
+            ObjInt(r.last.toLong()),
+            false
+        )
+    }
+
+    override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
+        return ObjString("RegexMath(${objRange.toString(scope)},${objGroups.toString(scope)})")
+    }
+
+    override suspend fun getAt(scope: Scope, index: Obj): Obj {
+        return objGroups.getAt(scope, index)
+    }
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        if( other === this) return 0
+        return -2
+    }
+
+    companion object {
+        val type by lazy {
+            object : ObjClass("RegexMatch") {
+                override suspend fun callOn(scope: Scope): Obj {
+                    scope.raiseError("RegexMatch can't be constructed directly")
+                }
+            }.apply {
+                addFn("groups") {
+                    thisAs<ObjRegexMatch>().objGroups
+                }
+                addFn("value") {
+                    thisAs<ObjRegexMatch>().objValue
+                }
+                addFn("range") {
+                    thisAs<ObjRegexMatch>().objRange
+                }
+            }
+        }
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjSet.kt

@@ -34,8 +34,19 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
         return ObjSet(
             if (other is ObjSet)
                 (set + other.set).toMutableSet()
-            else
+            else {
+                if( other.isInstanceOf(ObjIterable) ) {
+                    val otherSet = mutableSetOf<Obj>()
+                    other.enumerate(scope) {
+                        otherSet += it
+                        true
+                    }
+                    (set + otherSet).toMutableSet()
+                }
+                else {
                     (set + other).toMutableSet()
+                }
+            }
         )
     }
 
@@ -51,12 +62,14 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
 
             else -> {
                 if (other.isInstanceOf(ObjIterable)) {
-                    val i = other.invokeInstanceMethod(scope, "iterable")
+                    val otherSet = mutableSetOf<Obj>()
-                    while (i.invokeInstanceMethod(scope, "hasNext").toBool()) {
+                    other.enumerate(scope) {
-                        set += i.invokeInstanceMethod(scope, "next")
+                        otherSet += it
+                        true
                     }
+                    set += otherSet
                 }
-                set += other
+                else set += other
             }
         }
         return this
@@ -70,9 +83,19 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
     }
 
     override suspend fun minus(scope: Scope, other: Obj): Obj {
-        if (other !is ObjSet)
+        return when {
-            scope.raiseIllegalArgument("set operator - requires another set")
+            other is ObjSet -> ObjSet(set.minus(other.set).toMutableSet())
-        return ObjSet(set.minus(other.set).toMutableSet())
+            other.isInstanceOf(ObjIterable) -> {
+                val otherSet = mutableSetOf<Obj>()
+                other.enumerate(scope) {
+                    otherSet += it
+                    true
+                }
+                ObjSet((set - otherSet).toMutableSet())
+            }
+            else ->
+                scope.raiseIllegalArgument("set operator - requires another set or Iterable")
+        }
     }
 
     override fun toString(): String {

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/ObjString.kt

@@ -19,6 +19,8 @@ package net.sergeych.lyng.obj
 
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import net.sergeych.lyng.PerfFlags
+import net.sergeych.lyng.RegexCache
 import net.sergeych.lyng.Scope
 import net.sergeych.lyng.statement
 import net.sergeych.lynon.LynonDecoder
@@ -56,8 +58,9 @@ data class ObjString(val value: String) : Obj() {
     }
 
     override suspend fun getAt(scope: Scope, index: Obj): Obj {
-        if (index is ObjInt) return ObjChar(value[index.toInt()])
+        when (index) {
-        if (index is ObjRange) {
+            is ObjInt -> return ObjChar(value[index.toInt()])
+            is ObjRange -> {
                 val start = if (index.start == null || index.start.isNull) 0 else index.start.toInt()
                 val end = if (index.end == null || index.end.isNull) value.length else {
                     val e = index.end.toInt()
@@ -65,7 +68,13 @@ data class ObjString(val value: String) : Obj() {
                 }
                 return ObjString(value.substring(start, end))
             }
-        scope.raiseIllegalArgument("String index must be Int or Range")
+
+            is ObjRegex -> {
+                return index.find(this)
+            }
+
+            else -> scope.raiseIllegalArgument("String index must be Int, Regex or Range")
+        }
     }
 
     override fun hashCode(): Int {
@@ -96,6 +105,11 @@ data class ObjString(val value: String) : Obj() {
         return value == other.value
     }
 
+    override suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
+        val re = other.cast<ObjRegex>(scope)
+        return re.operatorMatch(scope, this)
+    }
+
     override suspend fun lynonType(): LynonType = LynonType.String
 
     override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
@@ -108,7 +122,8 @@ data class ObjString(val value: String) : Obj() {
                 ObjString(decoder.unpackBinaryData().decodeToString())
         }.apply {
             addFn("toInt") {
-                ObjInt(thisAs<ObjString>().value.toLongOrNull()
+                ObjInt(
+                    thisAs<ObjString>().value.toLongOrNull()
                         ?: raiseIllegalArgument("can't convert to int: $thisObj")
                 )
             }
@@ -160,6 +175,25 @@ data class ObjString(val value: String) : Obj() {
             addFn("trim") {
                 thisAs<ObjString>().value.trim().let(::ObjString)
             }
+            addFn("matches") {
+                val s = requireOnlyArg<Obj>()
+                val self = thisAs<ObjString>().value
+                ObjBool(
+                    when (s) {
+                        is ObjRegex -> self.matches(s.regex)
+                        is ObjString -> {
+                            if (s.value == ".*") true
+                            else {
+                                val re = if (PerfFlags.REGEX_CACHE) RegexCache.get(s.value) else s.value.toRegex()
+                                self.matches(re)
+                            }
+                        }
+
+                        else ->
+                            raiseIllegalArgument("can't match ${s.objClass.className}: required Regex or String")
+                    }
+                )
+            }
         }
     }
 }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/pacman/ImportProvider.kt

@@ -71,7 +71,7 @@ abstract class ImportProvider(
             newModuleAt(pos).also {
                 it.eval("import lyng.stdlib\n")
             }
-        }.copy()
+        }.createChildScope()
 }
 
 

lynglib/src/commonMain/kotlin/net/sergeych/lyng/statements.kt

@@ -60,7 +60,7 @@ abstract class Statement(
         val type = ObjClass("Callable")
     }
 
-    suspend fun call(scope: Scope, vararg args: Obj) = execute(scope.copy(args =  Arguments(*args)))
+    suspend fun call(scope: Scope, vararg args: Obj) = execute(scope.createChildScope(args =  Arguments(*args)))
 
 }
 

lynglib/src/commonMain/kotlin/net/sergeych/lyng/stdlib_included/root_lyng.kt

@@ -165,6 +165,8 @@ fun Exception.printStackTrace() {
     }
 }
 
+fun String.re() { Regex(this) }
+
     
 """.trimIndent()
 

lynglib/src/commonMain/kotlin/net/sergeych/lynon/BitList.kt

@@ -17,8 +17,10 @@
 
 package net.sergeych.lynon
 
+import kotlin.math.min
+
 @Suppress("unused")
-interface BitList {
+interface BitList: Comparable<BitList> {
     operator fun get(bitIndex: Long): Int
     operator fun set(bitIndex: Long,value: Int)
     val size: Long
@@ -31,6 +33,22 @@ interface BitList {
             if( index < size) this@BitList[index++]
             else null
     }
+
+    override fun compareTo(other: BitList): Int {
+        val m = min(size, other.size)
+        for( i in 0 ..< m) {
+            val a = this[i]
+            val b = other[i]
+            when {
+                a < b -> return -1
+                a > b -> return 1
+            }
+        }
+        if( size > other.size) return 1
+        if( size < other.size) return -1
+        return 0
+    }
+
 }
 
 fun bitListOf(vararg bits: Int): BitList {

lynglib/src/commonMain/kotlin/net/sergeych/lynon/LynonDecoder.kt

@@ -91,14 +91,15 @@ open class LynonDecoder(val bin: BitInput, val settings: LynonSettings = LynonSe
             val type = LynonType.entries[getBitsAsInt(4)]
             val list = mutableListOf<Obj>()
             val objClass = if (type == LynonType.Other)
-                decodeClassObj(scope).also { println("detected class obj: $it") }
+                decodeClassObj(scope)//.also { println("detected class obj: $it") }
             else type.objClass
             val size = fixedSize ?: bin.unpackUnsigned().toInt()
-            println("detected homogenous list type $type, $size items")
+//            println("detected homogenous list type $type, $size items")
             for (i in 0..<size) {
-                list += decodeObject(scope, objClass, type).also {
+                list += decodeObject(scope, objClass, type)
-                    println("decoded: $it")
+                //.also {
-                }
+//                    println("decoded: $it")
+//                }
             }
             list
         } else {

lynglib/src/commonMain/kotlin/net/sergeych/lynon/MemoryBitOutput.kt

@@ -17,13 +17,18 @@
 
 package net.sergeych.lynon
 
+import kotlinx.serialization.Serializable
 import kotlin.math.min
 
 /**
  * BitList implementation as fixed suze array of bits; indexing works exactly same as if
  * [MemoryBitInput] is used with [MemoryBitInput.getBit]. See [MemoryBitOutput] for
  * bits order and more information.
+ *
+ * It is [BitList] - comparable, and provides valid [hashCode] and [equals], so it could
+ * also be used as a key in maps.
  */
+@Serializable
 class BitArray(val bytes: UByteArray, val lastByteBits: Int) : BitList {
 
     val bytesSize: Int get() = bytes.size
@@ -73,7 +78,21 @@ class BitArray(val bytes: UByteArray, val lastByteBits: Int) : BitList {
     fun asByteArray(): ByteArray = bytes.asByteArray()
 
     @Suppress("unused")
-    fun asUbyteArray(): UByteArray = bytes
+    fun asUByteArray(): UByteArray = bytes
+
+    override fun equals(other: Any?): Boolean {
+        return when(other) {
+            is BitArray ->
+                // important: size must match as trailing zero bits will generate false eq otherwise:
+                size == other.size && bytes contentEquals other.bytes
+            is BitList -> compareTo(other) == 0
+            else -> false
+        }
+    }
+
+    override fun hashCode(): Int {
+        return bytes.contentHashCode()
+    }
 
     companion object {
 

lynglib/src/commonMain/kotlin/net/sergeych/lynon/bit_tools.kt

@@ -17,6 +17,8 @@
 
 package net.sergeych.lynon
 
+import kotlin.random.Random
+
 /**
  * Hoq many tetrades needed to store the value. It is faster to use this function
  * than to use sizeInBits
@@ -35,7 +37,7 @@ fun sizeInTetrades(value: ULong): Int {
 }
 
 /**
- * How many bits needed to store the value. Size for 0 is 1,
+ * Calculates ow many bits needed to store the value. Size for 0, for example, is 1.
  */
 @Suppress("unused")
 fun sizeInBits(value: ULong): Int {
@@ -50,3 +52,20 @@ fun sizeInBits(value: ULong): Int {
 }
 
 fun sizeInBits(value: Int): Int = sizeInBits(value.toULong())
+
+/**
+ * Generates a random BitArray of the specified size. Important: this is
+ * __not cryptographically secure__. Use random from [crypto2](https://gitea.sergeych.net/sergeych/crypto2),
+ * `randomInt()`, `randomUBytes()`, etc., for cryptographically secure random data.
+ *
+ * @param sizeInBits The size of the BitArray to generate in bits.
+ * @return A BitArray of the specified size filled with random bits.
+ */
+@Suppress("unused")
+fun BitArray.Companion.random(sizeInBits: Int): BitArray {
+    val result = BitArray.withBitSize(sizeInBits.toLong())
+    for (i in 0..<sizeInBits) {
+        result[i.toLong()] = Random.nextInt() and 1
+    }
+    return result
+}