1.2.1

AGENTS.md

@@ -6,9 +6,3 @@
 - If you need a wrapper for delegated properties, check for `getValue` explicitly and return a concrete `Statement` object when missing; avoid `onNotFoundResult` lambdas.
 - If wasmJs browser tests hang, first run `:lynglib:wasmJsNodeTest` and look for wasm compilation errors; hangs usually mean module instantiation failed.
 - Do not increase test timeouts to mask wasm generation errors; fix the invalid IR instead.
-
-## Type inference notes (notes/new_lyng_type_system_spec.md)
-- Nullability is Kotlin-style: `T` non-null, `T?` nullable, `!!` asserts non-null.
-- `void` is a singleton of class `Void` (syntax sugar for return type).
-- Object members are always allowed even on unknown types; non-Object members require explicit casts. Remove `inspect` from Object and use `toInspectString()` instead.
-- Do not reintroduce bytecode fallback opcodes (e.g., `GET_NAME`, `EVAL_*`, `CALL_FALLBACK`) or runtime name-resolution fallbacks; all symbol resolution must stay compile-time only.

LYNG_AI_SPEC.md

@@ -19,7 +19,6 @@ High-density specification for LLMs. Reference this for all Lyng code generation
 - **Equality**: `==` (equals), `!=` (not equals), `===` (ref identity), `!==` (ref not identity).
 - **Comparison**: `<`, `>`, `<=`, `>=`, `<=>` (shuttle/spaceship, returns -1, 0, 1).
 - **Destructuring**: `val [a, b, rest...] = list`. Supports nested `[a, [b, c]]` and splats.
-- **Compile-Time Resolution Only**: All names/members must resolve at compile time. No runtime name lookup or fallback opcodes.
 
 ## 2. Object-Oriented Programming (OOP)
 - **Multiple Inheritance**: Supported with **C3 MRO** (Python-style). Diamond-safe.
@@ -38,15 +37,6 @@ High-density specification for LLMs. Reference this for all Lyng code generation
 - **Disambiguation**: `this@Base.member()` or `(obj as Base).member()`. `as` returns a qualified view.
 - **Abstract/Interface**: `interface` is a synonym for `abstract class`. Both support state and constructors.
 - **Extensions**: `fun Class.ext()` or `val Class.ext get = ...`. Scope-isolated.
-- **Member Access**: Object members (`toString`, `toInspectString`, `let`, `also`, `apply`, `run`) are allowed on unknown types; all other members require a statically known receiver type or explicit cast.
-
-## 2.1 Type System (2026)
-- **Root Type**: Everything is an `Object` (root of the hierarchy).
-- **Nullability**: Non-null by default (`T`), nullable with `T?`, `!!` asserts non-null.
-- **Untyped params**: `fun foo(x)` -> `x: Object`, `fun foo(x?)` -> `x: Object?`.
-- **Untyped vars**: `var x` is `Unset` until first assignment locks the type.
-- **Inference**: List/map literals infer union element types; empty list is `List<Object>`, empty map is `{:}`.
-- **Generics**: Bounds with `T: A & B` or `T: A | B`; variance uses `out`/`in`.
 
 ## 3. Delegation (`by`)
 Unified model for `val`, `var`, and `fun`.
@@ -73,11 +63,11 @@ Delegate Methods:
 - **Collections**: `List` ( `[a, b]` ), `Map` ( `Map(k => v)` ), `Set` ( `Set(a, b)` ). `MapEntry` ( `k => v` ).
 
 ## 5. Patterns & Shorthands
-- **Map Literals**: `{ key: value, identifier: }` (identifier shorthand `x:` is `x: x`). Empty map is `{:}`.
+- **Map Literals**: `{ key: value, identifier: }` (identifier shorthand `x:` is `x: x`). Empty map is `Map()`.
 - **Named Arguments**: `fun(y: 10, x: 5)`. Shorthand: `Point(x:, y:)`.
 - **Varargs & Splats**: `fun f(args...)`, `f(...otherList)`.
 - **Labels**: `loop@ for(x in list) { if(x == 0) break@loop }`.
-- **Dynamic**: `val d = dynamic { get { name -> ... } }` allows `d.anyName` via explicit dynamic handler (not implicit fallback).
+- **Dynamic**: `val d = dynamic { get { name -> ... } }` allows `d.anyName`.
 
 ## 6. Operators & Methods to Overload
 | Op | Method | Op | Method |

docs/BytecodeSpec.md

@@ -1,280 +0,0 @@
-# Lyng Bytecode VM Spec v0 (Draft)
-
-This document describes a register-like (3-address) bytecode for Lyng with
-dynamic slot width (8/16/32-bit slot IDs), a slot-tail argument model, and
-typed lanes for Obj/Int/Real/Bool. The VM is intended to run as a suspendable
-interpreter and fall back to the existing AST execution when needed.
-
-## 1) Frame & Slot Model
-
-### Frame metadata
-- localCount: number of local slots for this function (fixed at compile time).
-- argCount: number of arguments passed at call time.
-- scopeSlotNames: optional debug names for scope slots (locals/params), aligned to slot mapping.
-- argBase = localCount.
-
-### Slot layout
-slots[0 .. localCount-1]              locals
-slots[localCount .. localCount+argCount-1]  arguments
-
-### Typed lanes
-- slotType[]: UNKNOWN/OBJ/INT/REAL/BOOL
-- objSlots[], intSlots[], realSlots[], boolSlots[]
-- A slot is a logical index; active lane is selected by slotType.
-
-### Parameter access
-- param i => slot localCount + i
-- variadic extra => slot localCount + declaredParamCount + k
-
-### Debug metadata (optional)
-- scopeSlotNames: array sized scopeSlotCount, each entry nullable.
-- Intended for disassembly/debug tooling; VM semantics do not depend on it.
-
-### Constant pool extras
-- SlotPlan: map of name -> slot index, used by PUSH_SCOPE to pre-allocate and map loop locals.
-- CallArgsPlan: ordered argument specs (name/splat) + tailBlock flag, used when argCount has the plan flag set.
-
-## 2) Slot ID Width
-
-Per frame, select:
-- 8-bit if localCount + argCount < 256
-- 16-bit if < 65536
-- 32-bit otherwise
-
-The decoder uses a dedicated loop per width. All slot operands are expanded to
-Int internally.
-
-## 3) CALL Semantics (Model A)
-
-Instruction:
-CALL_DIRECT fnId, argBase, argCount, dst
-
-Behavior:
-- Allocate a callee frame sized localCount + argCount.
-- Copy caller slots [argBase .. argBase+argCount-1] into callee slots
-  [localCount .. localCount+argCount-1].
-- Callee returns via RET slot or RET_VOID.
-- Caller stores return value to dst.
-
-Other calls:
-- CALL_VIRTUAL recvSlot, methodId, argBase, argCount, dst
-- CALL_FALLBACK stmtId, argBase, argCount, dst
-- CALL_SLOT calleeSlot, argBase, argCount, dst
-
-## 4) Binary Encoding Layout
-
-All instructions are:
-  [opcode:U8] [operands...]
-
-Operand widths:
-- slotId: S = 1/2/4 bytes (per frame slot width)
-- constId: K = 2 bytes (U16), extend to 4 if needed
-- ip: I = 2 bytes (U16) or 4 bytes (U32) per function size
-- fnId/methodId/stmtId: F/M/T = 2 bytes (U16) unless extended
-- argCount: C = 2 bytes (U16), extend to 4 if needed
-
-Endianness: little-endian for multi-byte operands.
-
-Common operand patterns:
-- S: one slot
-- SS: two slots
-- SSS: three slots
-- K S: constId + dst slot
-- S I: slot + jump target
-- I: jump target
-- F S C S: fnId, argBase slot, argCount, dst slot
-
-Arg count flag:
-- If high bit of C is set (0x8000), the low 15 bits encode a CallArgsPlan constId.
-- When not set, C is the raw positional count and tailBlockMode=false.
-
-## 5) Opcode Table
-
-Note: Any opcode can be compiled to FALLBACK if not implemented in a VM pass.
-
-### Data movement
-- NOP
-- MOVE_OBJ S -> S
-- MOVE_INT S -> S
-- MOVE_REAL S -> S
-- MOVE_BOOL S -> S
-- BOX_OBJ S -> S
-- CONST_OBJ K -> S
-- CONST_INT K -> S
-- CONST_REAL K -> S
-- CONST_BOOL K -> S
-- CONST_NULL -> S
-
-### Numeric conversions
-- INT_TO_REAL S -> S
-- REAL_TO_INT S -> S
-- BOOL_TO_INT S -> S
-- INT_TO_BOOL S -> S
-
-### Arithmetic: INT
-- ADD_INT S, S -> S
-- SUB_INT S, S -> S
-- MUL_INT S, S -> S
-- DIV_INT S, S -> S
-- MOD_INT S, S -> S
-- NEG_INT S -> S
-- INC_INT S
-- DEC_INT S
-
-### Arithmetic: REAL
-- ADD_REAL S, S -> S
-- SUB_REAL S, S -> S
-- MUL_REAL S, S -> S
-- DIV_REAL S, S -> S
-- NEG_REAL S -> S
-
-### Arithmetic: OBJ
-- ADD_OBJ S, S -> S
-- SUB_OBJ S, S -> S
-- MUL_OBJ S, S -> S
-- DIV_OBJ S, S -> S
-- MOD_OBJ S, S -> S
-
-### Bitwise: INT
-- AND_INT S, S -> S
-- OR_INT S, S -> S
-- XOR_INT S, S -> S
-- SHL_INT S, S -> S
-- SHR_INT S, S -> S
-- USHR_INT S, S -> S
-- INV_INT S -> S
-
-### Comparisons (typed)
-- CMP_EQ_INT S, S -> S
-- CMP_NEQ_INT S, S -> S
-- CMP_LT_INT S, S -> S
-- CMP_LTE_INT S, S -> S
-- CMP_GT_INT S, S -> S
-- CMP_GTE_INT S, S -> S
-- CMP_EQ_REAL S, S -> S
-- CMP_NEQ_REAL S, S -> S
-- CMP_LT_REAL S, S -> S
-- CMP_LTE_REAL S, S -> S
-- CMP_GT_REAL S, S -> S
-- CMP_GTE_REAL S, S -> S
-- CMP_EQ_BOOL S, S -> S
-- CMP_NEQ_BOOL S, S -> S
-
-### Mixed numeric comparisons
-- CMP_EQ_INT_REAL S, S -> S
-- CMP_EQ_REAL_INT S, S -> S
-- CMP_LT_INT_REAL S, S -> S
-- CMP_LT_REAL_INT S, S -> S
-- CMP_LTE_INT_REAL S, S -> S
-- CMP_LTE_REAL_INT S, S -> S
-- CMP_GT_INT_REAL S, S -> S
-- CMP_GT_REAL_INT S, S -> S
-- CMP_GTE_INT_REAL S, S -> S
-- CMP_GTE_REAL_INT S, S -> S
-- CMP_NEQ_INT_REAL S, S -> S
-- CMP_NEQ_REAL_INT S, S -> S
-- CMP_EQ_OBJ S, S -> S
-- CMP_NEQ_OBJ S, S -> S
-- CMP_REF_EQ_OBJ S, S -> S
-- CMP_REF_NEQ_OBJ S, S -> S
-- CMP_LT_OBJ S, S -> S
-- CMP_LTE_OBJ S, S -> S
-- CMP_GT_OBJ S, S -> S
-- CMP_GTE_OBJ S, S -> S
-
-### Boolean ops
-- NOT_BOOL S -> S
-- AND_BOOL S, S -> S
-- OR_BOOL S, S -> S
-
-### Control flow
-- JMP I
-- JMP_IF_TRUE S, I
-- JMP_IF_FALSE S, I
-- RET S
-- RET_VOID
-- PUSH_SCOPE K
-- POP_SCOPE
-
-### Scope setup
-- PUSH_SCOPE uses const `SlotPlan` (name -> slot index) to create a child scope and apply slot mapping.
-- POP_SCOPE restores the parent scope.
-
-### Calls
-- CALL_DIRECT F, S, C, S
-- CALL_VIRTUAL S, M, S, C, S
-- CALL_FALLBACK T, S, C, S
-- CALL_SLOT S, S, C, S
-
-### Object access (optional, later)
-- GET_FIELD S, M -> S
-- SET_FIELD S, M, S
-- GET_INDEX S, S -> S
-- SET_INDEX S, S, S
-
-### Fallback
-- EVAL_FALLBACK T -> S
-
-## 6) Const Pool Encoding (v0)
-
-Each const entry is encoded as:
-  [tag:U8] [payload...]
-
-Tags:
-- 0x00: NULL
-- 0x01: BOOL (payload: U8 0/1)
-- 0x02: INT (payload: S64, little-endian)
-- 0x03: REAL (payload: F64, IEEE-754, little-endian)
-- 0x04: STRING (payload: U32 length + UTF-8 bytes)
-- 0x05: OBJ_REF (payload: U32 index into external Obj table)
-
-Notes:
-- OBJ_REF is reserved for embedding prebuilt Obj handles if needed.
-- Strings use UTF-8; length is bytes, not chars.
-
-## 7) Function Header (binary container)
-
-Suggested layout for a bytecode function blob:
-- magic: U32 ("LYBC")
-- version: U16 (0x0001)
-- slotWidth: U8 (1,2,4)
-- ipWidth: U8 (2,4)
-- constIdWidth: U8 (2,4)
-- localCount: U32
-- codeSize: U32 (bytes)
-- constCount: U32
-- constPool: [const entries...]
-- code: [bytecode...]
-
-Const pool entries use the encoding described in section 6.
-
-## 8) Sample Bytecode (illustrative)
-
-Example Lyng:
-  val x = 2
-  val y = 3
-  val z = x + y
-
-Assume:
-- localCount = 3 (x,y,z)
-- argCount = 0
-- slot width = 1 byte
-- const pool: [INT 2, INT 3]
-
-Bytecode:
-  CONST_INT k0 -> s0
-  CONST_INT k1 -> s1
-  ADD_INT s0, s1 -> s2
-  RET_VOID
-
-Encoded (opcode values symbolic):
-  [OP_CONST_INT][k0][s0]
-  [OP_CONST_INT][k1][s1]
-  [OP_ADD_INT][s0][s1][s2]
-  [OP_RET_VOID]
-
-## 9) Notes
-
-- Mixed-mode is allowed: compiler can emit FALLBACK ops for unsupported nodes.
-- The VM must be suspendable; on suspension, store ip + minimal operand state.
-- Source mapping uses a separate ip->Pos table, not part of core bytecode.

docs/scopes_and_closures.md

@@ -1,7 +1,5 @@
 # Scopes and Closures: resolution and safety
 
-Attention to AI: name lookup is ibsolete and must not be used with bytecode compiler
-
 This page documents how name resolution works with `ClosureScope`, how to avoid recursion pitfalls, and how to safely capture and execute callbacks that need access to outer locals.
 
 ## Why this matters

lynglib/build.gradle.kts

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 group = "net.sergeych"
-version = "1.3.0-SNAPSHOT"
+version = "1.2.1"
 
 // Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
 

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

@@ -67,40 +67,24 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
                 for (i in params.indices) {
                     val a = params[i]
                     val value = arguments.list[i]
-                    val recordType = if (declaringClass != null && a.accessType != null) {
+                    scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
-                        ObjRecord.Type.ConstructorField
-                    } else {
-                        ObjRecord.Type.Argument
-                    }
-                    scope.addItem(
-                        a.name,
-                        (a.accessType ?: defaultAccessType).isMutable,
                         value.byValueCopy(),
                         a.visibility ?: defaultVisibility,
-                        recordType = recordType,
+                        recordType = ObjRecord.Type.Argument,
                         declaringClass = declaringClass,
-                        isTransient = a.isTransient
+                        isTransient = a.isTransient)
-                    )
                 }
                 return
             }
         }
 
         fun assign(a: Item, value: Obj) {
-            val recordType = if (declaringClass != null && a.accessType != null) {
+            scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
-                ObjRecord.Type.ConstructorField
-            } else {
-                ObjRecord.Type.Argument
-            }
-            scope.addItem(
-                a.name,
-                (a.accessType ?: defaultAccessType).isMutable,
                 value.byValueCopy(),
                 a.visibility ?: defaultVisibility,
-                recordType = recordType,
+                recordType = ObjRecord.Type.Argument,
                 declaringClass = declaringClass,
-                isTransient = a.isTransient
+                isTransient = a.isTransient)
-            )
         }
 
         // Prepare positional args and parameter count, handle tail-block binding

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

@@ -1,50 +0,0 @@
-/*
- * Copyright 2026 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
-
-class BlockStatement(
-    val block: Script,
-    val slotPlan: Map<String, Int>,
-    val captureSlots: List<CaptureSlot> = emptyList(),
-    private val startPos: Pos,
-) : Statement() {
-    override val pos: Pos = startPos
-
-    override suspend fun execute(scope: Scope): Obj {
-        val target = if (scope.skipScopeCreation) scope else scope.createChildScope(startPos)
-        if (slotPlan.isNotEmpty()) target.applySlotPlan(slotPlan)
-        if (captureSlots.isNotEmpty()) {
-            val applyScope = scope as? ApplyScope
-            for (capture in captureSlots) {
-                val rec = if (applyScope != null) {
-                    applyScope.resolveCaptureRecord(capture.name)
-                        ?: applyScope.callScope.resolveCaptureRecord(capture.name)
-                } else {
-                    scope.resolveCaptureRecord(capture.name)
-                } ?: (applyScope?.callScope ?: scope)
-                    .raiseSymbolNotFound("symbol ${capture.name} not found")
-                target.updateSlotFor(capture.name, rec)
-            }
-        }
-        return block.execute(target)
-    }
-
-    fun statements(): List<Statement> = block.debugStatements()
-
-}

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

@@ -1,23 +0,0 @@
-/*
- * Copyright 2026 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.bytecode.BytecodeStatement
-
-interface BytecodeBodyProvider {
-    fun bytecodeBody(): BytecodeStatement?
-}

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

@@ -1,24 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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
-
-/**
- * Compile-time call metadata for known functions. Used to select lambda receiver semantics.
- */
-data class CallSignature(
-    val tailBlockReceiverType: String? = null
-)

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

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

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

@@ -1,30 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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
-
-class ClassDeclStatement(
-    private val delegate: Statement,
-    private val startPos: Pos,
-) : Statement() {
-    override val pos: Pos = startPos
-
-    override suspend fun execute(scope: Scope): Obj {
-        return delegate.execute(scope)
-    }
-}

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

@@ -26,25 +26,12 @@ import net.sergeych.lyng.obj.ObjRecord
  * Inherits [Scope.args] and [Scope.thisObj] from [callScope] and adds lookup for symbols
  * from [closureScope] with proper precedence
  */
-class ClosureScope(
+class ClosureScope(val callScope: Scope, val closureScope: Scope) :
-    val callScope: Scope,
-    val closureScope: Scope,
-    private val preferredThisType: String? = null
-) :
     // 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 {
-        val desired = preferredThisType?.let { typeName ->
-            callScope.thisVariants.firstOrNull { it.objClass.className == typeName }
-        }
-        val primaryThis = closureScope.thisObj
-        val merged = ArrayList<Obj>(callScope.thisVariants.size + closureScope.thisVariants.size + 1)
-        desired?.let { merged.add(it) }
-        merged.addAll(callScope.thisVariants)
-        merged.addAll(closureScope.thisVariants)
-        setThisVariants(primaryThis, merged)
         // 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
@@ -84,15 +71,14 @@ class ClosureScope(
     }
 }
 
-class ApplyScope(val callScope: Scope, val applied: Scope) :
+class ApplyScope(_parent: Scope,val applied: Scope) : Scope(_parent, thisObj = applied.thisObj) {
-    Scope(callScope, thisObj = applied.thisObj) {
 
     override fun get(name: String): ObjRecord? {
         return applied.get(name) ?: super.get(name)
     }
 
-    override fun applyClosure(closure: Scope, preferredThisType: String?): Scope {
+    override fun applyClosure(closure: Scope): Scope {
-        return ClosureScope(this, closure, preferredThisType)
+        return this
     }
 
 }

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

@@ -19,23 +19,8 @@ package net.sergeych.lyng
 
 sealed class CodeContext {
     class Module(@Suppress("unused") val packageName: String?): CodeContext()
-    class Function(
+    class Function(val name: String): CodeContext()
-        val name: String,
-        val implicitThisMembers: Boolean = false,
-        val implicitThisTypeName: String? = null,
-        val typeParams: Set<String> = emptySet(),
-        val typeParamDecls: List<TypeDecl.TypeParam> = emptyList()
-    ): CodeContext()
     class ClassBody(val name: String, val isExtern: Boolean = false): CodeContext() {
-        var typeParams: Set<String> = emptySet()
-        var typeParamDecls: List<TypeDecl.TypeParam> = emptyList()
         val pendingInitializations = mutableMapOf<String, Pos>()
-        val declaredMembers = mutableSetOf<String>()
-        val memberOverrides = mutableMapOf<String, Boolean>()
-        val memberFieldIds = mutableMapOf<String, Int>()
-        val memberMethodIds = mutableMapOf<String, Int>()
-        var nextFieldId: Int = 0
-        var nextMethodId: Int = 0
-        var slotPlanId: Int? = null
     }
 }

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

@@ -1,54 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.ObjNull
-import net.sergeych.lyng.obj.ObjRecord
-import net.sergeych.lyng.obj.ObjString
-
-class DelegatedVarDeclStatement(
-    val name: String,
-    val isMutable: Boolean,
-    val visibility: Visibility,
-    val initializer: Statement,
-    val isTransient: Boolean,
-    private val startPos: Pos,
-) : Statement() {
-    override val pos: Pos = startPos
-
-    override suspend fun execute(context: Scope): Obj {
-        val initValue = initializer.execute(context)
-        val accessTypeStr = if (isMutable) "Var" else "Val"
-        val accessType = context.resolveQualifiedIdentifier("DelegateAccess.$accessTypeStr")
-        val finalDelegate = try {
-            initValue.invokeInstanceMethod(context, "bind", Arguments(ObjString(name), accessType, ObjNull))
-        } catch (e: Exception) {
-            initValue
-        }
-        val rec = context.addItem(
-            name,
-            isMutable,
-            ObjNull,
-            visibility,
-            recordType = ObjRecord.Type.Delegated,
-            isTransient = isTransient
-        )
-        rec.delegate = finalDelegate
-        return finalDelegate
-    }
-}

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

@@ -1,49 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.ListLiteralRef
-import net.sergeych.lyng.obj.Obj
-import net.sergeych.lyng.obj.ObjVoid
-
-class DestructuringVarDeclStatement(
-    val pattern: ListLiteralRef,
-    val names: List<String>,
-    val initializer: Statement,
-    val isMutable: Boolean,
-    val visibility: Visibility,
-    val isTransient: Boolean,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(context: Scope): Obj {
-        val value = initializer.execute(context)
-        for (name in names) {
-            context.addItem(name, true, ObjVoid, visibility, isTransient = isTransient)
-        }
-        pattern.setAt(pos, context, value)
-        if (!isMutable) {
-            for (name in names) {
-                val rec = context.objects[name]!!
-                val immutableRec = rec.copy(isMutable = false)
-                context.objects[name] = immutableRec
-                context.localBindings[name] = immutableRec
-                context.updateSlotFor(name, immutableRec)
-            }
-        }
-        return ObjVoid
-    }
-}

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

@@ -1,30 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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
-
-class EnumDeclStatement(
-    private val delegate: Statement,
-    private val startPos: Pos,
-) : Statement() {
-    override val pos: Pos = startPos
-
-    override suspend fun execute(scope: Scope): Obj {
-        return delegate.execute(scope)
-    }
-}

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

@@ -1,34 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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
-
-internal fun extensionCallableName(typeName: String, memberName: String): String {
-    return "__ext__${sanitizeExtensionTypeName(typeName)}__${memberName}"
-}
-
-internal fun extensionPropertyGetterName(typeName: String, memberName: String): String {
-    return "__ext_get__${sanitizeExtensionTypeName(typeName)}__${memberName}"
-}
-
-internal fun extensionPropertySetterName(typeName: String, memberName: String): String {
-    return "__ext_set__${sanitizeExtensionTypeName(typeName)}__${memberName}"
-}
-
-private fun sanitizeExtensionTypeName(typeName: String): String {
-    return typeName.replace('.', '_')
-}

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

@@ -1,60 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.ObjClass
-import net.sergeych.lyng.obj.ObjExtensionPropertyGetterCallable
-import net.sergeych.lyng.obj.ObjExtensionPropertySetterCallable
-import net.sergeych.lyng.obj.ObjProperty
-import net.sergeych.lyng.obj.ObjRecord
-
-class ExtensionPropertyDeclStatement(
-    val extTypeName: String,
-    val property: ObjProperty,
-    val visibility: Visibility,
-    val setterVisibility: Visibility?,
-    private val startPos: Pos,
-) : Statement() {
-    override val pos: Pos = startPos
-
-    override suspend fun execute(context: Scope): Obj {
-        val type = context[extTypeName]?.value ?: context.raiseSymbolNotFound("class $extTypeName not found")
-        if (type !is ObjClass) context.raiseClassCastError("$extTypeName is not the class instance")
-        context.addExtension(
-            type,
-            property.name,
-            ObjRecord(
-                property,
-                isMutable = false,
-                visibility = visibility,
-                writeVisibility = setterVisibility,
-                declaringClass = null,
-                type = ObjRecord.Type.Property
-            )
-        )
-        val getterName = extensionPropertyGetterName(extTypeName, property.name)
-        val getterWrapper = ObjExtensionPropertyGetterCallable(property.name, property)
-        context.addItem(getterName, false, getterWrapper, visibility, recordType = ObjRecord.Type.Fun)
-        if (property.setter != null) {
-            val setterName = extensionPropertySetterName(extTypeName, property.name)
-            val setterWrapper = ObjExtensionPropertySetterCallable(property.name, property)
-            context.addItem(setterName, false, setterWrapper, visibility, recordType = ObjRecord.Type.Fun)
-        }
-        return property
-    }
-}

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

@@ -1,30 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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
-
-class FunctionDeclStatement(
-    private val delegate: Statement,
-    private val startPos: Pos,
-) : Statement() {
-    override val pos: Pos = startPos
-
-    override suspend fun execute(scope: Scope): Obj {
-        return delegate.execute(scope)
-    }
-}

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

@@ -1,37 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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
-
-class InlineBlockStatement(
-    private val statements: List<Statement>,
-    private val startPos: Pos,
-) : Statement() {
-    override val pos: Pos = startPos
-
-    override suspend fun execute(scope: Scope): Obj {
-        var last: Obj = ObjVoid
-        for (stmt in statements) {
-            last = stmt.execute(scope)
-        }
-        return last
-    }
-
-    fun statements(): List<Statement> = statements
-}

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

@@ -59,7 +59,6 @@ class ModuleScope(
                         // when importing records, we keep track of its package (not otherwise needed)
                         if (record.importedFrom == null) record.importedFrom = this
                         scope.objects[newName] = record
-                        scope.updateSlotFor(newName, record)
                     }
                 }
             }
@@ -93,3 +92,4 @@ class ModuleScope(
     }
 }
 
+

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

@@ -72,5 +72,4 @@ object PerfFlags {
 
     // 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/Scope.kt

@@ -18,8 +18,6 @@
 package net.sergeych.lyng
 
 import net.sergeych.lyng.obj.*
-import net.sergeych.lyng.bytecode.CmdDisassembler
-import net.sergeych.lyng.bytecode.BytecodeStatement
 import net.sergeych.lyng.pacman.ImportManager
 import net.sergeych.lyng.pacman.ImportProvider
 
@@ -52,8 +50,6 @@ open class Scope(
     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()
-    @PublishedApi
-    internal val thisVariants: MutableList<Obj> = mutableListOf()
 
     // Fast-path storage for local variables/arguments accessed by slot index.
     // Enabled by default for child scopes; module/class scopes can ignore it.
@@ -68,21 +64,6 @@ open class Scope(
 
     internal val extensions: MutableMap<ObjClass, MutableMap<String, ObjRecord>> = mutableMapOf()
 
-    init {
-        setThisVariants(thisObj, parent?.thisVariants ?: emptyList())
-    }
-
-    internal fun setThisVariants(primary: Obj, extras: List<Obj>) {
-        thisObj = primary
-        thisVariants.clear()
-        thisVariants.add(primary)
-        for (obj in extras) {
-            if (obj !== primary && !thisVariants.contains(obj)) {
-                thisVariants.add(obj)
-            }
-        }
-    }
-
     fun addExtension(cls: ObjClass, name: String, record: ObjRecord) {
         extensions.getOrPut(cls) { mutableMapOf() }[name] = record
     }
@@ -143,14 +124,6 @@ open class Scope(
         }
         s.getSlotIndexOf(name)?.let { idx ->
             val rec = s.getSlotRecord(idx)
-            val hasDirectBinding =
-                s.objects.containsKey(name) ||
-                    s.localBindings.containsKey(name) ||
-                    (caller?.let { ctx ->
-                        s.objects.containsKey(ctx.mangledName(name)) ||
-                            s.localBindings.containsKey(ctx.mangledName(name))
-                    } ?: false)
-            if (!hasDirectBinding && rec.value === ObjUnset) return null
             if (rec.declaringClass == null || canAccessMember(rec.visibility, rec.declaringClass, caller, name)) return rec
         }
         return null
@@ -168,10 +141,6 @@ open class Scope(
         return null
     }
 
-    internal fun resolveCaptureRecord(name: String): ObjRecord? {
-        return chainLookupIgnoreClosure(name, followClosure = true, caller = currentClassCtx)
-    }
-
     /**
      * Perform base Scope.get semantics for this frame without delegating into parent.get
      * virtual dispatch. This checks:
@@ -357,25 +326,19 @@ open class Scope(
     }
 
     inline fun <reified T : Obj> thisAs(): T {
-        for (obj in thisVariants) {
+        var s: Scope? = this
-            if (obj is T) return obj
+        while (s != null) {
+            val t = s.thisObj
+            if (t is T) return t
+            s = s.parent
         }
         raiseClassCastError("Cannot cast ${thisObj.objClass.className} to ${T::class.simpleName}")
     }
 
     internal val objects = mutableMapOf<String, ObjRecord>()
 
-    internal fun getLocalRecordDirect(name: String): ObjRecord? = objects[name]
-
     open operator fun get(name: String): ObjRecord? {
         if (name == "this") return thisObj.asReadonly
-        if (name == "__PACKAGE__") {
-            var s: Scope? = this
-            while (s != null) {
-                if (s is ModuleScope) return s.packageNameObj
-                s = s.parent
-            }
-        }
 
         // 1. Prefer direct locals/bindings declared in this frame
         tryGetLocalRecord(this, name, currentClassCtx)?.let { return it }
@@ -416,12 +379,8 @@ open class Scope(
     fun setSlotValue(index: Int, newValue: Obj) {
         slots[index].value = newValue
     }
-    val slotCount: Int
-        get() = slots.size
 
     fun getSlotIndexOf(name: String): Int? = nameToSlot[name]
-
-    internal fun slotNameToIndexSnapshot(): Map<String, Int> = nameToSlot.toMap()
     fun allocateSlotFor(name: String, record: ObjRecord): Int {
         val idx = slots.size
         slots.add(record)
@@ -431,12 +390,6 @@ open class Scope(
 
     fun updateSlotFor(name: String, record: ObjRecord) {
         nameToSlot[name]?.let { slots[it] = record }
-        if (objects[name] == null) {
-            objects[name] = record
-        }
-        if (localBindings[name] == null) {
-            localBindings[name] = record
-        }
     }
 
     /**
@@ -457,48 +410,6 @@ open class Scope(
         }
     }
 
-    fun applySlotPlanWithSnapshot(plan: Map<String, Int>): Map<String, Int?> {
-        if (plan.isEmpty()) return emptyMap()
-        val maxIndex = plan.values.maxOrNull() ?: return emptyMap()
-        if (slots.size <= maxIndex) {
-            val targetSize = maxIndex + 1
-            while (slots.size < targetSize) {
-                slots.add(ObjRecord(ObjUnset, isMutable = true))
-            }
-        }
-        val snapshot = LinkedHashMap<String, Int?>(plan.size)
-        for ((name, idx) in plan) {
-            snapshot[name] = nameToSlot[name]
-            nameToSlot[name] = idx
-        }
-        return snapshot
-    }
-
-    fun restoreSlotPlan(snapshot: Map<String, Int?>) {
-        if (snapshot.isEmpty()) return
-        for ((name, idx) in snapshot) {
-            if (idx == null) {
-                nameToSlot.remove(name)
-            } else {
-                nameToSlot[name] = idx
-            }
-        }
-    }
-
-    fun hasSlotPlanConflict(plan: Map<String, Int>): Boolean {
-        if (plan.isEmpty() || nameToSlot.isEmpty()) return false
-        val planIndexToNames = HashMap<Int, HashSet<String>>(plan.size)
-        for ((name, idx) in plan) {
-            val names = planIndexToNames.getOrPut(idx) { HashSet(2) }
-            names.add(name)
-        }
-        for ((existingName, existingIndex) in nameToSlot) {
-            val plannedNames = planIndexToNames[existingIndex] ?: continue
-            if (!plannedNames.contains(existingName)) return true
-        }
-        return false
-    }
-
     /**
      * Clear all references and maps to prevent memory leaks when pooled.
      */
@@ -506,7 +417,6 @@ open class Scope(
         this.parent = null
         this.skipScopeCreation = false
         this.currentClassCtx = null
-        thisVariants.clear()
         objects.clear()
         slots.clear()
         nameToSlot.clear()
@@ -537,7 +447,7 @@ open class Scope(
         this.parent = parent
         this.args = args
         this.pos = pos
-        setThisVariants(thisObj, parent?.thisVariants ?: emptyList())
+        this.thisObj = thisObj
         // Pre-size local slots for upcoming parameter assignment where possible
         reserveLocalCapacity(args.list.size + 4)
     }
@@ -626,10 +536,7 @@ open class Scope(
         isAbstract: Boolean = false,
         isClosed: Boolean = false,
         isOverride: Boolean = false,
-        isTransient: Boolean = false,
+        isTransient: Boolean = false
-        callSignature: CallSignature? = null,
-        fieldId: Int? = null,
-        methodId: Int? = null
     ): ObjRecord {
         val rec = ObjRecord(
             value, isMutable, visibility, writeVisibility,
@@ -638,19 +545,15 @@ open class Scope(
             isAbstract = isAbstract,
             isClosed = isClosed,
             isOverride = isOverride,
-            isTransient = isTransient,
+            isTransient = isTransient
-            callSignature = callSignature,
-            memberName = name,
-            fieldId = fieldId,
-            methodId = methodId
         )
         objects[name] = rec
         bumpClassLayoutIfNeeded(name, value, recordType)
         if (recordType == ObjRecord.Type.Field || recordType == ObjRecord.Type.ConstructorField) {
             val inst = thisObj as? net.sergeych.lyng.obj.ObjInstance
             if (inst != null) {
-                val slotId = rec.fieldId ?: inst.objClass.fieldSlotForKey(name)?.slot
+                val slot = inst.objClass.fieldSlotForKey(name)
-                if (slotId != null) inst.setFieldSlotRecord(slotId, rec)
+                if (slot != null) inst.setFieldSlotRecord(slot.slot, rec)
             }
         }
         if (value is Statement ||
@@ -659,8 +562,8 @@ open class Scope(
             recordType == ObjRecord.Type.Property) {
             val inst = thisObj as? net.sergeych.lyng.obj.ObjInstance
             if (inst != null) {
-                val slotId = rec.methodId ?: inst.objClass.methodSlotForKey(name)?.slot
+                val slot = inst.objClass.methodSlotForKey(name)
-                if (slotId != null) inst.setMethodSlotRecord(slotId, rec)
+                if (slot != null) inst.setMethodSlotRecord(slot.slot, rec)
             }
         }
         // Index this binding within the current frame to help resolve locals across suspension
@@ -712,16 +615,7 @@ open class Scope(
         }
     }
 
-    fun disassembleSymbol(name: String): String {
+    fun addFn(vararg names: String, fn: suspend Scope.() -> Obj) {
-        val record = get(name) ?: return "$name is not found"
-        val stmt = record.value as? Statement ?: return "$name is not a compiled body"
-        val bytecode = (stmt as? BytecodeStatement)?.bytecodeFunction()
-            ?: (stmt as? BytecodeBodyProvider)?.bytecodeBody()?.bytecodeFunction()
-            ?: return "$name is not a compiled body"
-        return CmdDisassembler.disassemble(bytecode)
-    }
-
-    fun addFn(vararg names: String, callSignature: CallSignature? = null, fn: suspend Scope.() -> Obj) {
         val newFn = object : Statement() {
             override val pos: Pos = Pos.builtIn
 
@@ -732,9 +626,7 @@ open class Scope(
             addItem(
                 name,
                 false,
-                newFn,
+                newFn
-                recordType = ObjRecord.Type.Fun,
-                callSignature = callSignature
             )
         }
     }
@@ -748,10 +640,9 @@ open class Scope(
         eval(code.toSource())
 
     suspend fun eval(source: Source): Obj {
-        return Compiler.compileWithResolution(
+        return Compiler.compile(
             source,
-            currentImportProvider,
+            currentImportProvider
-            seedScope = this
         ).execute(this)
     }
 
@@ -804,8 +695,7 @@ open class Scope(
         println("--------------------")
     }
 
-    open fun applyClosure(closure: Scope, preferredThisType: String? = null): Scope =
+    open fun applyClosure(closure: Scope): Scope = ClosureScope(this, closure)
-        ClosureScope(this, closure, preferredThisType)
 
     /**
      * Resolve and evaluate a qualified identifier exactly as compiled code would.
@@ -817,25 +707,11 @@ open class Scope(
         val trimmed = qualifiedName.trim()
         if (trimmed.isEmpty()) raiseSymbolNotFound("empty identifier")
         val parts = trimmed.split('.')
-        val first = parts[0]
+        var ref: ObjRef = LocalVarRef(parts[0], Pos.builtIn)
-        val ref: ObjRef = if (first == "this") {
-            ConstRef(thisObj.asReadonly)
-        } else {
-            var s: Scope? = this
-            var slot: Int? = null
-            var guard = 0
-            while (s != null && guard++ < 1024 && slot == null) {
-                slot = s.getSlotIndexOf(first)
-                s = s.parent
-            }
-            if (slot == null) raiseSymbolNotFound(first)
-            LocalSlotRef(first, slot, 0, isMutable = false, isDelegated = false, Pos.builtIn, strict = true)
-        }
-        var ref0: ObjRef = ref
         for (i in 1 until parts.size) {
-            ref0 = FieldRef(ref0, parts[i], false)
+            ref = FieldRef(ref, parts[i], false)
         }
-        return ref0.evalValue(this)
+        return ref.evalValue(this)
     }
 
     suspend fun resolve(rec: ObjRecord, name: String): Obj {

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

@@ -32,15 +32,10 @@ import kotlin.math.*
 class Script(
     override val pos: Pos,
     private val statements: List<Statement> = emptyList(),
-    private val moduleSlotPlan: Map<String, Int> = emptyMap(),
 //    private val catchReturn: Boolean = false,
 ) : Statement() {
 
     override suspend fun execute(scope: Scope): Obj {
-        if (moduleSlotPlan.isNotEmpty()) {
-            scope.applySlotPlan(moduleSlotPlan)
-            seedModuleSlots(scope)
-        }
         var lastResult: Obj = ObjVoid
         for (s in statements) {
             lastResult = s.execute(scope)
@@ -48,45 +43,6 @@ class Script(
         return lastResult
     }
 
-    private fun seedModuleSlots(scope: Scope) {
-        val parent = scope.parent ?: return
-        for (name in moduleSlotPlan.keys) {
-            if (scope.objects.containsKey(name)) {
-                scope.updateSlotFor(name, scope.objects[name]!!)
-                continue
-            }
-            val seed = findSeedRecord(parent, name)
-            if (seed != null) {
-                if (name == "Exception" && seed.value !is ObjClass) {
-                    scope.updateSlotFor(name, ObjRecord(ObjException.Root, isMutable = false))
-                } else {
-                    scope.updateSlotFor(name, seed)
-                }
-                continue
-            }
-            if (name == "Exception") {
-                scope.updateSlotFor(name, ObjRecord(ObjException.Root, isMutable = false))
-            }
-        }
-    }
-
-    private fun findSeedRecord(scope: Scope?, name: String): ObjRecord? {
-        var s = scope
-        var hops = 0
-        while (s != null && hops++ < 1024) {
-            s.objects[name]?.let { return it }
-            s.localBindings[name]?.let { return it }
-            s.getSlotIndexOf(name)?.let { idx ->
-                val rec = s.getSlotRecord(idx)
-                if (rec.value !== ObjUnset) return rec
-            }
-            s = s.parent
-        }
-        return null
-    }
-
-    internal fun debugStatements(): List<Statement> = statements
-
     suspend fun execute() = execute(
         defaultImportManager.newStdScope()
     )
@@ -369,30 +325,6 @@ class Script(
                 this.trace(args.getOrNull(0)?.toString() ?: "")
                 ObjVoid
             }
-            addFn("run") {
-                requireOnlyArg<Statement>().execute(this)
-            }
-            addFn("cached") {
-                val builder = requireOnlyArg<Statement>()
-                val capturedScope = this
-                var calculated = false
-                var cachedValue: Obj = ObjVoid
-                val thunk = object : Statement() {
-                    override val pos: Pos = Pos.builtIn
-                    override suspend fun execute(scope: Scope): Obj {
-                        if (!calculated) {
-                            cachedValue = builder.execute(capturedScope)
-                            calculated = true
-                        }
-                        return cachedValue
-                    }
-                }
-                thunk
-            }
-            addFn("lazy") {
-                val builder = requireOnlyArg<Statement>()
-                ObjLazyDelegate(builder, this)
-            }
 
             addVoidFn("delay") {
                 val a = args.firstAndOnly()
@@ -428,11 +360,8 @@ class Script(
             addConst("CompletableDeferred", ObjCompletableDeferred.type)
             addConst("Mutex", ObjMutex.type)
             addConst("Flow", ObjFlow.type)
-            addConst("FlowBuilder", ObjFlowBuilder.type)
 
             addConst("Regex", ObjRegex.type)
-            addConst("RegexMatch", ObjRegexMatch.type)
-            addConst("MapEntry", ObjMapEntry.type)
 
             addFn("launch") {
                 val callable = requireOnlyArg<Statement>()
@@ -446,7 +375,7 @@ class Script(
                 ObjVoid
             }
 
-            addFn("flow", callSignature = CallSignature(tailBlockReceiverType = "FlowBuilder")) {
+            addFn("flow") {
                 // important is: current context contains closure often used in call;
                 // we'll need it for the producer
                 ObjFlow(requireOnlyArg<Statement>(), this)

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

@@ -1,30 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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
-
-class TryStatement(
-    private val delegate: Statement,
-    private val startPos: Pos,
-) : Statement() {
-    override val pos: Pos = startPos
-
-    override suspend fun execute(scope: Scope): Obj {
-        return delegate.execute(scope)
-    }
-}

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

@@ -22,23 +22,8 @@ package net.sergeych.lyng
 // this is highly experimental and subject to complete redesign
 // very soon
 sealed class TypeDecl(val isNullable:Boolean = false) {
-    enum class Variance { In, Out, Invariant }
     // ??
-    data class Function(
+//    data class Fn(val argTypes: List<ArgsDeclaration.Item>, val retType: TypeDecl) : TypeDecl()
-        val receiver: TypeDecl?,
-        val params: List<TypeDecl>,
-        val returnType: TypeDecl,
-        val nullable: Boolean = false
-    ) : TypeDecl(nullable)
-    data class TypeVar(val name: String, val nullable: Boolean = false) : TypeDecl(nullable)
-    data class Union(val options: List<TypeDecl>, val nullable: Boolean = false) : TypeDecl(nullable)
-    data class Intersection(val options: List<TypeDecl>, val nullable: Boolean = false) : TypeDecl(nullable)
-    data class TypeParam(
-        val name: String,
-        val variance: Variance = Variance.Invariant,
-        val bound: TypeDecl? = null,
-        val defaultType: TypeDecl? = null
-    )
     object TypeAny : TypeDecl()
     object TypeNullableAny : TypeDecl(true)
 

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

@@ -1,50 +0,0 @@
-/*
- * Copyright 2026 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.ObjClass
-import net.sergeych.lyng.obj.ObjNull
-import net.sergeych.lyng.obj.ObjRecord
-import net.sergeych.lyng.obj.ObjUnset
-
-class VarDeclStatement(
-    val name: String,
-    val isMutable: Boolean,
-    val visibility: Visibility,
-    val initializer: Statement?,
-    val isTransient: Boolean,
-    val slotIndex: Int?,
-    val scopeId: Int?,
-    private val startPos: Pos,
-    val initializerObjClass: ObjClass? = null,
-) : Statement() {
-    override val pos: Pos = startPos
-
-    override suspend fun execute(context: Scope): Obj {
-        val initValue = initializer?.execute(context)?.byValueCopy() ?: ObjUnset
-        context.addItem(
-            name,
-            isMutable,
-            initValue,
-            visibility,
-            recordType = ObjRecord.Type.Other,
-            isTransient = isTransient
-        )
-        return initValue
-    }
-}

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

@@ -1,76 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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
-
-sealed class WhenCondition(open val expr: Statement, open val pos: Pos) {
-    abstract suspend fun matches(scope: Scope, value: Obj): Boolean
-}
-
-class WhenEqualsCondition(
-    override val expr: Statement,
-    override val pos: Pos,
-) : WhenCondition(expr, pos) {
-    override suspend fun matches(scope: Scope, value: Obj): Boolean {
-        return expr.execute(scope).compareTo(scope, value) == 0
-    }
-}
-
-class WhenInCondition(
-    override val expr: Statement,
-    val negated: Boolean,
-    override val pos: Pos,
-) : WhenCondition(expr, pos) {
-    override suspend fun matches(scope: Scope, value: Obj): Boolean {
-        val result = expr.execute(scope).contains(scope, value)
-        return if (negated) !result else result
-    }
-}
-
-class WhenIsCondition(
-    override val expr: Statement,
-    val negated: Boolean,
-    override val pos: Pos,
-) : WhenCondition(expr, pos) {
-    override suspend fun matches(scope: Scope, value: Obj): Boolean {
-        val result = value.isInstanceOf(expr.execute(scope))
-        return if (negated) !result else result
-    }
-}
-
-data class WhenCase(val conditions: List<WhenCondition>, val block: Statement)
-
-class WhenStatement(
-    val value: Statement,
-    val cases: List<WhenCase>,
-    val elseCase: Statement?,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        val whenValue = value.execute(scope)
-        for (case in cases) {
-            for (condition in case.conditions) {
-                if (condition.matches(scope, whenValue)) {
-                    return case.block.execute(scope)
-                }
-            }
-        }
-        return elseCase?.execute(scope) ?: ObjVoid
-    }
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/BytecodeCompileException.kt

@@ -1,28 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.bytecode
-
-import net.sergeych.lyng.Pos
-
-class BytecodeCompileException(
-    message: String,
-    val pos: Pos? = null,
-) : RuntimeException(message) {
-    override fun toString(): String =
-        pos?.let { "${super.toString()} at $it" } ?: super.toString()
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/BytecodeConst.kt

@@ -1,51 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.bytecode
-
-import net.sergeych.lyng.Pos
-import net.sergeych.lyng.Visibility
-import net.sergeych.lyng.obj.Obj
-import net.sergeych.lyng.obj.ObjProperty
-
-sealed class BytecodeConst {
-    object Null : BytecodeConst()
-    data class Bool(val value: Boolean) : BytecodeConst()
-    data class IntVal(val value: Long) : BytecodeConst()
-    data class RealVal(val value: Double) : BytecodeConst()
-    data class StringVal(val value: String) : BytecodeConst()
-    data class PosVal(val pos: Pos) : BytecodeConst()
-    data class ObjRef(val value: Obj) : BytecodeConst()
-    data class Ref(val value: net.sergeych.lyng.obj.ObjRef) : BytecodeConst()
-    data class StatementVal(val statement: net.sergeych.lyng.Statement) : BytecodeConst()
-    data class ListLiteralPlan(val spreads: List<Boolean>) : BytecodeConst()
-    data class ValueFn(val fn: suspend (net.sergeych.lyng.Scope) -> net.sergeych.lyng.obj.ObjRecord) : BytecodeConst()
-    data class SlotPlan(val plan: Map<String, Int>, val captures: List<String> = emptyList()) : BytecodeConst()
-    data class ExtensionPropertyDecl(
-        val extTypeName: String,
-        val property: ObjProperty,
-        val visibility: Visibility,
-        val setterVisibility: Visibility?,
-    ) : BytecodeConst()
-    data class LocalDecl(
-        val name: String,
-        val isMutable: Boolean,
-        val visibility: Visibility,
-        val isTransient: Boolean,
-    ) : BytecodeConst()
-    data class CallArgsPlan(val tailBlock: Boolean, val specs: List<CallArgSpec>) : BytecodeConst()
-    data class CallArgSpec(val name: String?, val isSplat: Boolean)
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/BytecodeFrame.kt

@@ -1,72 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.bytecode
-
-import net.sergeych.lyng.obj.Obj
-import net.sergeych.lyng.obj.ObjNull
-
-class BytecodeFrame(
-    val localCount: Int,
-    val argCount: Int,
-) {
-    val slotCount: Int = localCount + argCount
-    val argBase: Int = localCount
-
-    private val slotTypes: ByteArray = ByteArray(slotCount) { SlotType.UNKNOWN.code }
-    private val objSlots: Array<Obj?> = arrayOfNulls(slotCount)
-    private val intSlots: LongArray = LongArray(slotCount)
-    private val realSlots: DoubleArray = DoubleArray(slotCount)
-    private val boolSlots: BooleanArray = BooleanArray(slotCount)
-
-    fun getSlotType(slot: Int): SlotType = SlotType.values().first { it.code == slotTypes[slot] }
-    fun getSlotTypeCode(slot: Int): Byte = slotTypes[slot]
-    fun setSlotType(slot: Int, type: SlotType) {
-        slotTypes[slot] = type.code
-    }
-
-    fun getObj(slot: Int): Obj = objSlots[slot] ?: ObjNull
-    fun setObj(slot: Int, value: Obj) {
-        objSlots[slot] = value
-        slotTypes[slot] = SlotType.OBJ.code
-    }
-
-    fun getInt(slot: Int): Long = intSlots[slot]
-    fun setInt(slot: Int, value: Long) {
-        intSlots[slot] = value
-        slotTypes[slot] = SlotType.INT.code
-    }
-
-    fun getReal(slot: Int): Double = realSlots[slot]
-    fun setReal(slot: Int, value: Double) {
-        realSlots[slot] = value
-        slotTypes[slot] = SlotType.REAL.code
-    }
-
-    fun getBool(slot: Int): Boolean = boolSlots[slot]
-    fun setBool(slot: Int, value: Boolean) {
-        boolSlots[slot] = value
-        slotTypes[slot] = SlotType.BOOL.code
-    }
-
-    fun clearSlot(slot: Int) {
-        slotTypes[slot] = SlotType.UNKNOWN.code
-        objSlots[slot] = null
-        intSlots[slot] = 0L
-        realSlots[slot] = 0.0
-        boolSlots[slot] = false
-    }
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/BytecodeStatement.kt

@@ -1,264 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.bytecode
-
-import net.sergeych.lyng.Pos
-import net.sergeych.lyng.Scope
-import net.sergeych.lyng.Statement
-import net.sergeych.lyng.DestructuringVarDeclStatement
-import net.sergeych.lyng.WhenCase
-import net.sergeych.lyng.WhenCondition
-import net.sergeych.lyng.WhenEqualsCondition
-import net.sergeych.lyng.WhenInCondition
-import net.sergeych.lyng.WhenIsCondition
-import net.sergeych.lyng.WhenStatement
-import net.sergeych.lyng.obj.Obj
-import net.sergeych.lyng.obj.ObjClass
-import net.sergeych.lyng.obj.RangeRef
-
-class BytecodeStatement private constructor(
-    val original: Statement,
-    private val function: CmdFunction,
-) : Statement(original.isStaticConst, original.isConst, original.returnType) {
-    override val pos: Pos = original.pos
-
-    override suspend fun execute(scope: Scope): Obj {
-        scope.pos = pos
-        return CmdVm().execute(function, scope, scope.args.list)
-    }
-
-    internal fun bytecodeFunction(): CmdFunction = function
-
-    companion object {
-        fun wrap(
-            statement: Statement,
-            nameHint: String,
-            allowLocalSlots: Boolean,
-            returnLabels: Set<String> = emptySet(),
-            rangeLocalNames: Set<String> = emptySet(),
-            allowedScopeNames: Set<String>? = null,
-            slotTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
-            knownNameObjClass: Map<String, ObjClass> = emptyMap(),
-        ): Statement {
-            if (statement is BytecodeStatement) return statement
-            val hasUnsupported = containsUnsupportedStatement(statement)
-            if (hasUnsupported) {
-                val statementName = statement::class.qualifiedName ?: statement::class.simpleName ?: "UnknownStatement"
-                throw BytecodeCompileException(
-                    "Bytecode compile error: unsupported statement $statementName in '$nameHint'",
-                    statement.pos
-                )
-            }
-            val safeLocals = allowLocalSlots
-            val compiler = BytecodeCompiler(
-                allowLocalSlots = safeLocals,
-                returnLabels = returnLabels,
-                rangeLocalNames = rangeLocalNames,
-                allowedScopeNames = allowedScopeNames,
-                slotTypeByScopeId = slotTypeByScopeId,
-                knownNameObjClass = knownNameObjClass
-            )
-            val compiled = compiler.compileStatement(nameHint, statement)
-            val fn = compiled ?: throw BytecodeCompileException(
-                "Bytecode compile error: failed to compile '$nameHint'",
-                statement.pos
-            )
-            return BytecodeStatement(statement, fn)
-        }
-
-        private fun containsUnsupportedStatement(stmt: Statement): Boolean {
-            val target = if (stmt is BytecodeStatement) stmt.original else stmt
-            return when (target) {
-                is net.sergeych.lyng.ExpressionStatement -> {
-                    val ref = target.ref
-                    if (ref is net.sergeych.lyng.obj.StatementRef) {
-                        containsUnsupportedStatement(ref.statement)
-                    } else {
-                        false
-                    }
-                }
-                is net.sergeych.lyng.IfStatement -> {
-                    containsUnsupportedStatement(target.condition) ||
-                        containsUnsupportedStatement(target.ifBody) ||
-                        (target.elseBody?.let { containsUnsupportedStatement(it) } ?: false)
-                }
-                is net.sergeych.lyng.ForInStatement -> {
-                    val unsupported = containsUnsupportedStatement(target.source) ||
-                        containsUnsupportedStatement(target.body) ||
-                        (target.elseStatement?.let { containsUnsupportedStatement(it) } ?: false)
-                    unsupported
-                }
-                is net.sergeych.lyng.WhileStatement -> {
-                    containsUnsupportedStatement(target.condition) ||
-                        containsUnsupportedStatement(target.body) ||
-                        (target.elseStatement?.let { containsUnsupportedStatement(it) } ?: false)
-                }
-                is net.sergeych.lyng.DoWhileStatement -> {
-                    containsUnsupportedStatement(target.body) ||
-                        containsUnsupportedStatement(target.condition) ||
-                        (target.elseStatement?.let { containsUnsupportedStatement(it) } ?: false)
-                }
-                is net.sergeych.lyng.BlockStatement ->
-                    target.statements().any { containsUnsupportedStatement(it) }
-                is net.sergeych.lyng.InlineBlockStatement ->
-                    target.statements().any { containsUnsupportedStatement(it) }
-                is net.sergeych.lyng.VarDeclStatement ->
-                    target.initializer?.let { containsUnsupportedStatement(it) } ?: false
-                is net.sergeych.lyng.DelegatedVarDeclStatement ->
-                    containsUnsupportedStatement(target.initializer)
-                is net.sergeych.lyng.DestructuringVarDeclStatement ->
-                    containsUnsupportedStatement(target.initializer)
-                is net.sergeych.lyng.BreakStatement ->
-                    target.resultExpr?.let { containsUnsupportedStatement(it) } ?: false
-                is net.sergeych.lyng.ContinueStatement -> false
-                is net.sergeych.lyng.ReturnStatement ->
-                    target.resultExpr?.let { containsUnsupportedStatement(it) } ?: false
-                is net.sergeych.lyng.ThrowStatement ->
-                    containsUnsupportedStatement(target.throwExpr)
-                is net.sergeych.lyng.ExtensionPropertyDeclStatement -> false
-                is net.sergeych.lyng.ClassDeclStatement -> false
-                is net.sergeych.lyng.FunctionDeclStatement -> false
-                is net.sergeych.lyng.EnumDeclStatement -> false
-                is net.sergeych.lyng.TryStatement -> true
-                is net.sergeych.lyng.WhenStatement -> {
-                    containsUnsupportedStatement(target.value) ||
-                        target.cases.any { case ->
-                            case.conditions.any { cond -> containsUnsupportedStatement(cond.expr) } ||
-                                containsUnsupportedStatement(case.block)
-                        } ||
-                        (target.elseCase?.let { containsUnsupportedStatement(it) } ?: false)
-                }
-                else -> true
-            }
-        }
-
-        private fun unwrapDeep(stmt: Statement): Statement {
-            return when (stmt) {
-                is BytecodeStatement -> unwrapDeep(stmt.original)
-                is net.sergeych.lyng.BlockStatement -> {
-                    val unwrapped = stmt.statements().map { unwrapDeep(it) }
-                    net.sergeych.lyng.BlockStatement(
-                        net.sergeych.lyng.Script(stmt.pos, unwrapped),
-                        stmt.slotPlan,
-                        stmt.captureSlots,
-                        stmt.pos
-                    )
-                }
-                is net.sergeych.lyng.VarDeclStatement -> {
-                    net.sergeych.lyng.VarDeclStatement(
-                        stmt.name,
-                        stmt.isMutable,
-                        stmt.visibility,
-                        stmt.initializer?.let { unwrapDeep(it) },
-                        stmt.isTransient,
-                        stmt.slotIndex,
-                        stmt.scopeId,
-                        stmt.pos,
-                        stmt.initializerObjClass
-                    )
-                }
-                is net.sergeych.lyng.DestructuringVarDeclStatement -> {
-                    net.sergeych.lyng.DestructuringVarDeclStatement(
-                        stmt.pattern,
-                        stmt.names,
-                        unwrapDeep(stmt.initializer),
-                        stmt.isMutable,
-                        stmt.visibility,
-                        stmt.isTransient,
-                        stmt.pos
-                    )
-                }
-                is net.sergeych.lyng.IfStatement -> {
-                    net.sergeych.lyng.IfStatement(
-                        unwrapDeep(stmt.condition),
-                        unwrapDeep(stmt.ifBody),
-                        stmt.elseBody?.let { unwrapDeep(it) },
-                        stmt.pos
-                    )
-                }
-                is net.sergeych.lyng.ForInStatement -> {
-                    net.sergeych.lyng.ForInStatement(
-                        stmt.loopVarName,
-                        unwrapDeep(stmt.source),
-                        stmt.constRange,
-                        unwrapDeep(stmt.body),
-                        stmt.elseStatement?.let { unwrapDeep(it) },
-                        stmt.label,
-                        stmt.canBreak,
-                        stmt.loopSlotPlan,
-                        stmt.pos
-                    )
-                }
-                is net.sergeych.lyng.WhileStatement -> {
-                    net.sergeych.lyng.WhileStatement(
-                        unwrapDeep(stmt.condition),
-                        unwrapDeep(stmt.body),
-                        stmt.elseStatement?.let { unwrapDeep(it) },
-                        stmt.label,
-                        stmt.canBreak,
-                        stmt.loopSlotPlan,
-                        stmt.pos
-                    )
-                }
-                is net.sergeych.lyng.DoWhileStatement -> {
-                    net.sergeych.lyng.DoWhileStatement(
-                        unwrapDeep(stmt.body),
-                        unwrapDeep(stmt.condition),
-                        stmt.elseStatement?.let { unwrapDeep(it) },
-                        stmt.label,
-                        stmt.loopSlotPlan,
-                        stmt.pos
-                    )
-                }
-                is net.sergeych.lyng.BreakStatement -> {
-                    val resultExpr = stmt.resultExpr?.let { unwrapDeep(it) }
-                    net.sergeych.lyng.BreakStatement(stmt.label, resultExpr, stmt.pos)
-                }
-                is net.sergeych.lyng.ContinueStatement ->
-                    net.sergeych.lyng.ContinueStatement(stmt.label, stmt.pos)
-                is net.sergeych.lyng.ReturnStatement -> {
-                    val resultExpr = stmt.resultExpr?.let { unwrapDeep(it) }
-                    net.sergeych.lyng.ReturnStatement(stmt.label, resultExpr, stmt.pos)
-                }
-                is net.sergeych.lyng.ThrowStatement ->
-                    net.sergeych.lyng.ThrowStatement(unwrapDeep(stmt.throwExpr), stmt.pos)
-                is net.sergeych.lyng.WhenStatement -> {
-                    net.sergeych.lyng.WhenStatement(
-                        unwrapDeep(stmt.value),
-                        stmt.cases.map { case ->
-                            net.sergeych.lyng.WhenCase(
-                                case.conditions.map { unwrapWhenCondition(it) },
-                                unwrapDeep(case.block)
-                            )
-                        },
-                        stmt.elseCase?.let { unwrapDeep(it) },
-                        stmt.pos
-                    )
-                }
-                else -> stmt
-            }
-        }
-
-        private fun unwrapWhenCondition(cond: WhenCondition): WhenCondition {
-            return when (cond) {
-                is WhenEqualsCondition -> WhenEqualsCondition(unwrapDeep(cond.expr), cond.pos)
-                is WhenInCondition -> WhenInCondition(unwrapDeep(cond.expr), cond.negated, cond.pos)
-                is WhenIsCondition -> WhenIsCondition(unwrapDeep(cond.expr), cond.negated, cond.pos)
-            }
-        }
-    }
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/CmdBuilder.kt

@@ -1,383 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.bytecode
-
-class CmdBuilder {
-    sealed interface Operand {
-        data class IntVal(val value: Int) : Operand
-        data class LabelRef(val label: Label) : Operand
-    }
-
-    data class Label(val id: Int)
-
-    data class Instr(val op: Opcode, val operands: List<Operand>)
-
-    private val instructions = mutableListOf<Instr>()
-    private val constPool = mutableListOf<BytecodeConst>()
-    private val labelPositions = mutableMapOf<Label, Int>()
-    private var nextLabelId = 0
-
-    fun addConst(c: BytecodeConst): Int {
-        constPool += c
-        return constPool.lastIndex
-    }
-
-    fun emit(op: Opcode, vararg operands: Int) {
-        instructions += Instr(op, operands.map { Operand.IntVal(it) })
-    }
-
-    fun emit(op: Opcode, operands: List<Operand>) {
-        instructions += Instr(op, operands)
-    }
-
-    fun label(): Label = Label(nextLabelId++)
-
-    fun mark(label: Label) {
-        labelPositions[label] = instructions.size
-    }
-
-    fun build(
-        name: String,
-        localCount: Int,
-        addrCount: Int = 0,
-        returnLabels: Set<String> = emptySet(),
-        scopeSlotIndices: IntArray = IntArray(0),
-        scopeSlotNames: Array<String?> = emptyArray(),
-        scopeSlotIsModule: BooleanArray = BooleanArray(0),
-        localSlotNames: Array<String?> = emptyArray(),
-        localSlotMutables: BooleanArray = BooleanArray(0)
-    ): CmdFunction {
-        val scopeSlotCount = scopeSlotIndices.size
-        require(scopeSlotNames.isEmpty() || scopeSlotNames.size == scopeSlotCount) {
-            "scope slot name mapping size mismatch"
-        }
-        require(scopeSlotIsModule.isEmpty() || scopeSlotIsModule.size == scopeSlotCount) {
-            "scope slot module mapping size mismatch"
-        }
-        require(localSlotNames.size == localSlotMutables.size) { "local slot metadata size mismatch" }
-        val labelIps = mutableMapOf<Label, Int>()
-        for ((label, idx) in labelPositions) {
-            labelIps[label] = idx
-        }
-        val cmds = ArrayList<Cmd>(instructions.size)
-        for (ins in instructions) {
-            val kinds = operandKinds(ins.op)
-            if (kinds.size != ins.operands.size) {
-                error("Operand count mismatch for ${ins.op}: expected ${kinds.size}, got ${ins.operands.size}")
-            }
-            val operands = IntArray(kinds.size)
-            for (i in kinds.indices) {
-                val operand = ins.operands[i]
-                val v = when (operand) {
-                    is Operand.IntVal -> operand.value
-                    is Operand.LabelRef -> labelIps[operand.label]
-                        ?: error("Unknown label ${operand.label.id} for ${ins.op}")
-                }
-                operands[i] = v
-            }
-            cmds.add(createCmd(ins.op, operands, scopeSlotCount))
-        }
-        return CmdFunction(
-            name = name,
-            localCount = localCount,
-            addrCount = addrCount,
-            returnLabels = returnLabels,
-            scopeSlotCount = scopeSlotCount,
-            scopeSlotIndices = scopeSlotIndices,
-            scopeSlotNames = if (scopeSlotNames.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotNames,
-            scopeSlotIsModule = if (scopeSlotIsModule.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotIsModule,
-            localSlotNames = localSlotNames,
-            localSlotMutables = localSlotMutables,
-            constants = constPool.toList(),
-            cmds = cmds.toTypedArray()
-        )
-    }
-
-    private fun operandKinds(op: Opcode): List<OperandKind> {
-        return when (op) {
-            Opcode.NOP, Opcode.RET_VOID, Opcode.POP_SCOPE, Opcode.POP_SLOT_PLAN -> emptyList()
-            Opcode.MOVE_OBJ, Opcode.MOVE_INT, Opcode.MOVE_REAL, Opcode.MOVE_BOOL, Opcode.BOX_OBJ,
-            Opcode.INT_TO_REAL, Opcode.REAL_TO_INT, Opcode.BOOL_TO_INT, Opcode.INT_TO_BOOL,
-            Opcode.OBJ_TO_BOOL,
-            Opcode.NEG_INT, Opcode.NEG_REAL, Opcode.NOT_BOOL, Opcode.INV_INT,
-            Opcode.ASSERT_IS ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.CHECK_IS ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.RANGE_INT_BOUNDS ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.RET_LABEL, Opcode.THROW ->
-                listOf(OperandKind.CONST, OperandKind.SLOT)
-            Opcode.RESOLVE_SCOPE_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.ADDR)
-            Opcode.LOAD_OBJ_ADDR, Opcode.LOAD_INT_ADDR, Opcode.LOAD_REAL_ADDR, Opcode.LOAD_BOOL_ADDR ->
-                listOf(OperandKind.ADDR, OperandKind.SLOT)
-            Opcode.STORE_OBJ_ADDR, Opcode.STORE_INT_ADDR, Opcode.STORE_REAL_ADDR, Opcode.STORE_BOOL_ADDR ->
-                listOf(OperandKind.SLOT, OperandKind.ADDR)
-            Opcode.CONST_NULL ->
-                listOf(OperandKind.SLOT)
-            Opcode.CONST_OBJ, Opcode.CONST_INT, Opcode.CONST_REAL, Opcode.CONST_BOOL, Opcode.MAKE_VALUE_FN ->
-                listOf(OperandKind.CONST, OperandKind.SLOT)
-            Opcode.PUSH_SCOPE, Opcode.PUSH_SLOT_PLAN ->
-                listOf(OperandKind.CONST)
-            Opcode.DECL_LOCAL, Opcode.DECL_EXT_PROPERTY ->
-                listOf(OperandKind.CONST, OperandKind.SLOT)
-            Opcode.ADD_INT, Opcode.SUB_INT, Opcode.MUL_INT, Opcode.DIV_INT, Opcode.MOD_INT,
-            Opcode.ADD_REAL, Opcode.SUB_REAL, Opcode.MUL_REAL, Opcode.DIV_REAL,
-            Opcode.AND_INT, Opcode.OR_INT, Opcode.XOR_INT, Opcode.SHL_INT, Opcode.SHR_INT, Opcode.USHR_INT,
-            Opcode.CMP_EQ_INT, Opcode.CMP_NEQ_INT, Opcode.CMP_LT_INT, Opcode.CMP_LTE_INT,
-            Opcode.CMP_GT_INT, Opcode.CMP_GTE_INT,
-            Opcode.CMP_EQ_REAL, Opcode.CMP_NEQ_REAL, Opcode.CMP_LT_REAL, Opcode.CMP_LTE_REAL,
-            Opcode.CMP_GT_REAL, Opcode.CMP_GTE_REAL,
-            Opcode.CMP_EQ_BOOL, Opcode.CMP_NEQ_BOOL,
-            Opcode.CMP_EQ_INT_REAL, Opcode.CMP_EQ_REAL_INT, Opcode.CMP_LT_INT_REAL, Opcode.CMP_LT_REAL_INT,
-            Opcode.CMP_LTE_INT_REAL, Opcode.CMP_LTE_REAL_INT, Opcode.CMP_GT_INT_REAL, Opcode.CMP_GT_REAL_INT,
-            Opcode.CMP_GTE_INT_REAL, Opcode.CMP_GTE_REAL_INT, Opcode.CMP_NEQ_INT_REAL, Opcode.CMP_NEQ_REAL_INT,
-            Opcode.CMP_EQ_OBJ, Opcode.CMP_NEQ_OBJ, Opcode.CMP_REF_EQ_OBJ, Opcode.CMP_REF_NEQ_OBJ,
-            Opcode.CMP_LT_OBJ, Opcode.CMP_LTE_OBJ, Opcode.CMP_GT_OBJ, Opcode.CMP_GTE_OBJ,
-            Opcode.ADD_OBJ, Opcode.SUB_OBJ, Opcode.MUL_OBJ, Opcode.DIV_OBJ, Opcode.MOD_OBJ, Opcode.CONTAINS_OBJ,
-            Opcode.AND_BOOL, Opcode.OR_BOOL ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.ASSIGN_OP_OBJ ->
-                listOf(OperandKind.ID, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.CONST)
-            Opcode.INC_INT, Opcode.DEC_INT, Opcode.RET, Opcode.LOAD_THIS ->
-                listOf(OperandKind.SLOT)
-            Opcode.LOAD_THIS_VARIANT ->
-                listOf(OperandKind.ID, OperandKind.SLOT)
-            Opcode.JMP ->
-                listOf(OperandKind.IP)
-            Opcode.JMP_IF_TRUE, Opcode.JMP_IF_FALSE ->
-                listOf(OperandKind.SLOT, OperandKind.IP)
-            Opcode.CALL_DIRECT ->
-                listOf(OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
-            Opcode.CALL_MEMBER_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
-            Opcode.CALL_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
-            Opcode.GET_INDEX ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.SET_INDEX ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.MAKE_RANGE ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.LIST_LITERAL ->
-                listOf(OperandKind.CONST, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
-            Opcode.GET_MEMBER_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT)
-            Opcode.SET_MEMBER_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT)
-            Opcode.ITER_PUSH ->
-                listOf(OperandKind.SLOT)
-            Opcode.ITER_POP, Opcode.ITER_CANCEL ->
-                emptyList()
-        }
-    }
-
-    private enum class OperandKind {
-        SLOT,
-        ADDR,
-        CONST,
-        IP,
-        COUNT,
-        ID,
-    }
-
-    private fun createCmd(op: Opcode, operands: IntArray, scopeSlotCount: Int): Cmd {
-        return when (op) {
-            Opcode.NOP -> CmdNop()
-            Opcode.MOVE_OBJ -> CmdMoveObj(operands[0], operands[1])
-            Opcode.MOVE_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount) {
-                CmdMoveIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
-            } else {
-                CmdMoveInt(operands[0], operands[1])
-            }
-            Opcode.MOVE_REAL -> CmdMoveReal(operands[0], operands[1])
-            Opcode.MOVE_BOOL -> CmdMoveBool(operands[0], operands[1])
-            Opcode.CONST_OBJ -> CmdConstObj(operands[0], operands[1])
-            Opcode.CONST_INT -> if (operands[1] >= scopeSlotCount) {
-                CmdConstIntLocal(operands[0], operands[1] - scopeSlotCount)
-            } else {
-                CmdConstInt(operands[0], operands[1])
-            }
-            Opcode.CONST_REAL -> CmdConstReal(operands[0], operands[1])
-            Opcode.CONST_BOOL -> CmdConstBool(operands[0], operands[1])
-            Opcode.CONST_NULL -> CmdConstNull(operands[0])
-            Opcode.MAKE_VALUE_FN -> CmdMakeValueFn(operands[0], operands[1])
-            Opcode.BOX_OBJ -> CmdBoxObj(operands[0], operands[1])
-            Opcode.OBJ_TO_BOOL -> CmdObjToBool(operands[0], operands[1])
-            Opcode.RANGE_INT_BOUNDS -> CmdRangeIntBounds(operands[0], operands[1], operands[2], operands[3])
-            Opcode.LOAD_THIS -> CmdLoadThis(operands[0])
-            Opcode.LOAD_THIS_VARIANT -> CmdLoadThisVariant(operands[0], operands[1])
-            Opcode.MAKE_RANGE -> CmdMakeRange(operands[0], operands[1], operands[2], operands[3])
-            Opcode.CHECK_IS -> CmdCheckIs(operands[0], operands[1], operands[2])
-            Opcode.ASSERT_IS -> CmdAssertIs(operands[0], operands[1])
-            Opcode.RET_LABEL -> CmdRetLabel(operands[0], operands[1])
-            Opcode.THROW -> CmdThrow(operands[0], operands[1])
-            Opcode.RESOLVE_SCOPE_SLOT -> CmdResolveScopeSlot(operands[0], operands[1])
-            Opcode.LOAD_OBJ_ADDR -> CmdLoadObjAddr(operands[0], operands[1])
-            Opcode.STORE_OBJ_ADDR -> CmdStoreObjAddr(operands[0], operands[1])
-            Opcode.LOAD_INT_ADDR -> CmdLoadIntAddr(operands[0], operands[1])
-            Opcode.STORE_INT_ADDR -> CmdStoreIntAddr(operands[0], operands[1])
-            Opcode.LOAD_REAL_ADDR -> CmdLoadRealAddr(operands[0], operands[1])
-            Opcode.STORE_REAL_ADDR -> CmdStoreRealAddr(operands[0], operands[1])
-            Opcode.LOAD_BOOL_ADDR -> CmdLoadBoolAddr(operands[0], operands[1])
-            Opcode.STORE_BOOL_ADDR -> CmdStoreBoolAddr(operands[0], operands[1])
-            Opcode.INT_TO_REAL -> CmdIntToReal(operands[0], operands[1])
-            Opcode.REAL_TO_INT -> CmdRealToInt(operands[0], operands[1])
-            Opcode.BOOL_TO_INT -> CmdBoolToInt(operands[0], operands[1])
-            Opcode.INT_TO_BOOL -> CmdIntToBool(operands[0], operands[1])
-            Opcode.ADD_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdAddIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdAddInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.SUB_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdSubIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdSubInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.MUL_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdMulIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdMulInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.DIV_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdDivIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdDivInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.MOD_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdModIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdModInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.NEG_INT -> CmdNegInt(operands[0], operands[1])
-            Opcode.INC_INT -> if (operands[0] >= scopeSlotCount) {
-                CmdIncIntLocal(operands[0] - scopeSlotCount)
-            } else {
-                CmdIncInt(operands[0])
-            }
-            Opcode.DEC_INT -> if (operands[0] >= scopeSlotCount) {
-                CmdDecIntLocal(operands[0] - scopeSlotCount)
-            } else {
-                CmdDecInt(operands[0])
-            }
-            Opcode.ADD_REAL -> CmdAddReal(operands[0], operands[1], operands[2])
-            Opcode.SUB_REAL -> CmdSubReal(operands[0], operands[1], operands[2])
-            Opcode.MUL_REAL -> CmdMulReal(operands[0], operands[1], operands[2])
-            Opcode.DIV_REAL -> CmdDivReal(operands[0], operands[1], operands[2])
-            Opcode.NEG_REAL -> CmdNegReal(operands[0], operands[1])
-            Opcode.AND_INT -> CmdAndInt(operands[0], operands[1], operands[2])
-            Opcode.OR_INT -> CmdOrInt(operands[0], operands[1], operands[2])
-            Opcode.XOR_INT -> CmdXorInt(operands[0], operands[1], operands[2])
-            Opcode.SHL_INT -> CmdShlInt(operands[0], operands[1], operands[2])
-            Opcode.SHR_INT -> CmdShrInt(operands[0], operands[1], operands[2])
-            Opcode.USHR_INT -> CmdUshrInt(operands[0], operands[1], operands[2])
-            Opcode.INV_INT -> CmdInvInt(operands[0], operands[1])
-            Opcode.CMP_EQ_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdCmpEqIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdCmpEqInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.CMP_NEQ_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdCmpNeqIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdCmpNeqInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.CMP_LT_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdCmpLtIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdCmpLtInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.CMP_LTE_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdCmpLteIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdCmpLteInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.CMP_GT_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdCmpGtIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdCmpGtInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.CMP_GTE_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) {
-                CmdCmpGteIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
-            } else {
-                CmdCmpGteInt(operands[0], operands[1], operands[2])
-            }
-            Opcode.CMP_EQ_REAL -> CmdCmpEqReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_NEQ_REAL -> CmdCmpNeqReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_LT_REAL -> CmdCmpLtReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_LTE_REAL -> CmdCmpLteReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_GT_REAL -> CmdCmpGtReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_GTE_REAL -> CmdCmpGteReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_EQ_BOOL -> CmdCmpEqBool(operands[0], operands[1], operands[2])
-            Opcode.CMP_NEQ_BOOL -> CmdCmpNeqBool(operands[0], operands[1], operands[2])
-            Opcode.CMP_EQ_INT_REAL -> CmdCmpEqIntReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_EQ_REAL_INT -> CmdCmpEqRealInt(operands[0], operands[1], operands[2])
-            Opcode.CMP_LT_INT_REAL -> CmdCmpLtIntReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_LT_REAL_INT -> CmdCmpLtRealInt(operands[0], operands[1], operands[2])
-            Opcode.CMP_LTE_INT_REAL -> CmdCmpLteIntReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_LTE_REAL_INT -> CmdCmpLteRealInt(operands[0], operands[1], operands[2])
-            Opcode.CMP_GT_INT_REAL -> CmdCmpGtIntReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_GT_REAL_INT -> CmdCmpGtRealInt(operands[0], operands[1], operands[2])
-            Opcode.CMP_GTE_INT_REAL -> CmdCmpGteIntReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_GTE_REAL_INT -> CmdCmpGteRealInt(operands[0], operands[1], operands[2])
-            Opcode.CMP_NEQ_INT_REAL -> CmdCmpNeqIntReal(operands[0], operands[1], operands[2])
-            Opcode.CMP_NEQ_REAL_INT -> CmdCmpNeqRealInt(operands[0], operands[1], operands[2])
-            Opcode.CMP_EQ_OBJ -> CmdCmpEqObj(operands[0], operands[1], operands[2])
-            Opcode.CMP_NEQ_OBJ -> CmdCmpNeqObj(operands[0], operands[1], operands[2])
-            Opcode.CMP_REF_EQ_OBJ -> CmdCmpRefEqObj(operands[0], operands[1], operands[2])
-            Opcode.CMP_REF_NEQ_OBJ -> CmdCmpRefNeqObj(operands[0], operands[1], operands[2])
-            Opcode.NOT_BOOL -> CmdNotBool(operands[0], operands[1])
-            Opcode.AND_BOOL -> CmdAndBool(operands[0], operands[1], operands[2])
-            Opcode.OR_BOOL -> CmdOrBool(operands[0], operands[1], operands[2])
-            Opcode.CMP_LT_OBJ -> CmdCmpLtObj(operands[0], operands[1], operands[2])
-            Opcode.CMP_LTE_OBJ -> CmdCmpLteObj(operands[0], operands[1], operands[2])
-            Opcode.CMP_GT_OBJ -> CmdCmpGtObj(operands[0], operands[1], operands[2])
-            Opcode.CMP_GTE_OBJ -> CmdCmpGteObj(operands[0], operands[1], operands[2])
-            Opcode.ADD_OBJ -> CmdAddObj(operands[0], operands[1], operands[2])
-            Opcode.SUB_OBJ -> CmdSubObj(operands[0], operands[1], operands[2])
-            Opcode.MUL_OBJ -> CmdMulObj(operands[0], operands[1], operands[2])
-            Opcode.DIV_OBJ -> CmdDivObj(operands[0], operands[1], operands[2])
-            Opcode.MOD_OBJ -> CmdModObj(operands[0], operands[1], operands[2])
-            Opcode.CONTAINS_OBJ -> CmdContainsObj(operands[0], operands[1], operands[2])
-            Opcode.ASSIGN_OP_OBJ -> CmdAssignOpObj(operands[0], operands[1], operands[2], operands[3], operands[4])
-            Opcode.JMP -> CmdJmp(operands[0])
-            Opcode.JMP_IF_TRUE -> CmdJmpIfTrue(operands[0], operands[1])
-            Opcode.JMP_IF_FALSE -> CmdJmpIfFalse(operands[0], operands[1])
-            Opcode.RET -> CmdRet(operands[0])
-            Opcode.RET_VOID -> CmdRetVoid()
-            Opcode.PUSH_SCOPE -> CmdPushScope(operands[0])
-            Opcode.POP_SCOPE -> CmdPopScope()
-            Opcode.PUSH_SLOT_PLAN -> CmdPushSlotPlan(operands[0])
-            Opcode.POP_SLOT_PLAN -> CmdPopSlotPlan()
-            Opcode.DECL_LOCAL -> CmdDeclLocal(operands[0], operands[1])
-            Opcode.DECL_EXT_PROPERTY -> CmdDeclExtProperty(operands[0], operands[1])
-            Opcode.CALL_DIRECT -> CmdCallDirect(operands[0], operands[1], operands[2], operands[3])
-            Opcode.CALL_MEMBER_SLOT -> CmdCallMemberSlot(operands[0], operands[1], operands[2], operands[3], operands[4])
-            Opcode.CALL_SLOT -> CmdCallSlot(operands[0], operands[1], operands[2], operands[3])
-            Opcode.GET_INDEX -> CmdGetIndex(operands[0], operands[1], operands[2])
-            Opcode.SET_INDEX -> CmdSetIndex(operands[0], operands[1], operands[2])
-            Opcode.LIST_LITERAL -> CmdListLiteral(operands[0], operands[1], operands[2], operands[3])
-            Opcode.GET_MEMBER_SLOT -> CmdGetMemberSlot(operands[0], operands[1], operands[2], operands[3])
-            Opcode.SET_MEMBER_SLOT -> CmdSetMemberSlot(operands[0], operands[1], operands[2], operands[3])
-            Opcode.ITER_PUSH -> CmdIterPush(operands[0])
-            Opcode.ITER_POP -> CmdIterPop()
-            Opcode.ITER_CANCEL -> CmdIterCancel()
-        }
-    }
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/CmdDisassembler.kt

@@ -1,280 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.bytecode
-
-object CmdDisassembler {
-    fun disassemble(fn: CmdFunction): String {
-        val out = StringBuilder()
-        val cmds = fn.cmds
-        for (i in cmds.indices) {
-            val (op, opValues) = opAndOperands(fn, cmds[i])
-            val kinds = operandKinds(op)
-            val operands = ArrayList<String>(kinds.size)
-            for (k in kinds.indices) {
-                val v = opValues.getOrElse(k) { 0 }
-                when (kinds[k]) {
-                    OperandKind.SLOT -> {
-                        val name = when {
-                            v < fn.scopeSlotCount -> fn.scopeSlotNames[v]
-                            else -> {
-                                val localIndex = v - fn.scopeSlotCount
-                                fn.localSlotNames.getOrNull(localIndex)
-                            }
-                        }
-                        operands += if (name != null) "s$v($name)" else "s$v"
-                    }
-                    OperandKind.ADDR -> operands += "a$v"
-                    OperandKind.CONST -> operands += "k$v"
-                    OperandKind.IP -> operands += "ip$v"
-                    OperandKind.COUNT -> operands += "n$v"
-                    OperandKind.ID -> operands += "#$v"
-                }
-            }
-            out.append(i).append(": ").append(op.name)
-            if (operands.isNotEmpty()) {
-                out.append(' ').append(operands.joinToString(", "))
-            }
-            out.append('\n')
-        }
-        return out.toString()
-    }
-
-    private fun opAndOperands(fn: CmdFunction, cmd: Cmd): Pair<Opcode, IntArray> {
-        return when (cmd) {
-            is CmdNop -> Opcode.NOP to intArrayOf()
-            is CmdMoveObj -> Opcode.MOVE_OBJ to intArrayOf(cmd.src, cmd.dst)
-            is CmdMoveInt -> Opcode.MOVE_INT to intArrayOf(cmd.src, cmd.dst)
-            is CmdMoveIntLocal -> Opcode.MOVE_INT to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdMoveReal -> Opcode.MOVE_REAL to intArrayOf(cmd.src, cmd.dst)
-            is CmdMoveBool -> Opcode.MOVE_BOOL to intArrayOf(cmd.src, cmd.dst)
-            is CmdConstObj -> Opcode.CONST_OBJ to intArrayOf(cmd.constId, cmd.dst)
-            is CmdConstInt -> Opcode.CONST_INT to intArrayOf(cmd.constId, cmd.dst)
-            is CmdConstIntLocal -> Opcode.CONST_INT to intArrayOf(cmd.constId, cmd.dst + fn.scopeSlotCount)
-            is CmdConstReal -> Opcode.CONST_REAL to intArrayOf(cmd.constId, cmd.dst)
-            is CmdConstBool -> Opcode.CONST_BOOL to intArrayOf(cmd.constId, cmd.dst)
-            is CmdLoadThis -> Opcode.LOAD_THIS to intArrayOf(cmd.dst)
-            is CmdLoadThisVariant -> Opcode.LOAD_THIS_VARIANT to intArrayOf(cmd.typeId, cmd.dst)
-            is CmdConstNull -> Opcode.CONST_NULL to intArrayOf(cmd.dst)
-            is CmdMakeValueFn -> Opcode.MAKE_VALUE_FN to intArrayOf(cmd.id, cmd.dst)
-            is CmdBoxObj -> Opcode.BOX_OBJ to intArrayOf(cmd.src, cmd.dst)
-            is CmdObjToBool -> Opcode.OBJ_TO_BOOL to intArrayOf(cmd.src, cmd.dst)
-            is CmdCheckIs -> Opcode.CHECK_IS to intArrayOf(cmd.objSlot, cmd.typeSlot, cmd.dst)
-            is CmdAssertIs -> Opcode.ASSERT_IS to intArrayOf(cmd.objSlot, cmd.typeSlot)
-            is CmdRangeIntBounds -> Opcode.RANGE_INT_BOUNDS to intArrayOf(cmd.src, cmd.startSlot, cmd.endSlot, cmd.okSlot)
-            is CmdMakeRange -> Opcode.MAKE_RANGE to intArrayOf(cmd.startSlot, cmd.endSlot, cmd.inclusiveSlot, cmd.dst)
-            is CmdResolveScopeSlot -> Opcode.RESOLVE_SCOPE_SLOT to intArrayOf(cmd.scopeSlot, cmd.addrSlot)
-            is CmdLoadObjAddr -> Opcode.LOAD_OBJ_ADDR to intArrayOf(cmd.addrSlot, cmd.dst)
-            is CmdStoreObjAddr -> Opcode.STORE_OBJ_ADDR to intArrayOf(cmd.src, cmd.addrSlot)
-            is CmdLoadIntAddr -> Opcode.LOAD_INT_ADDR to intArrayOf(cmd.addrSlot, cmd.dst)
-            is CmdStoreIntAddr -> Opcode.STORE_INT_ADDR to intArrayOf(cmd.src, cmd.addrSlot)
-            is CmdLoadRealAddr -> Opcode.LOAD_REAL_ADDR to intArrayOf(cmd.addrSlot, cmd.dst)
-            is CmdStoreRealAddr -> Opcode.STORE_REAL_ADDR to intArrayOf(cmd.src, cmd.addrSlot)
-            is CmdLoadBoolAddr -> Opcode.LOAD_BOOL_ADDR to intArrayOf(cmd.addrSlot, cmd.dst)
-            is CmdStoreBoolAddr -> Opcode.STORE_BOOL_ADDR to intArrayOf(cmd.src, cmd.addrSlot)
-            is CmdIntToReal -> Opcode.INT_TO_REAL to intArrayOf(cmd.src, cmd.dst)
-            is CmdRealToInt -> Opcode.REAL_TO_INT to intArrayOf(cmd.src, cmd.dst)
-            is CmdBoolToInt -> Opcode.BOOL_TO_INT to intArrayOf(cmd.src, cmd.dst)
-            is CmdIntToBool -> Opcode.INT_TO_BOOL to intArrayOf(cmd.src, cmd.dst)
-            is CmdAddInt -> Opcode.ADD_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdAddIntLocal -> Opcode.ADD_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdSubInt -> Opcode.SUB_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdSubIntLocal -> Opcode.SUB_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdMulInt -> Opcode.MUL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdMulIntLocal -> Opcode.MUL_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdDivInt -> Opcode.DIV_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdDivIntLocal -> Opcode.DIV_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdModInt -> Opcode.MOD_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdModIntLocal -> Opcode.MOD_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdNegInt -> Opcode.NEG_INT to intArrayOf(cmd.src, cmd.dst)
-            is CmdIncInt -> Opcode.INC_INT to intArrayOf(cmd.slot)
-            is CmdIncIntLocal -> Opcode.INC_INT to intArrayOf(cmd.slot + fn.scopeSlotCount)
-            is CmdDecInt -> Opcode.DEC_INT to intArrayOf(cmd.slot)
-            is CmdDecIntLocal -> Opcode.DEC_INT to intArrayOf(cmd.slot + fn.scopeSlotCount)
-            is CmdAddReal -> Opcode.ADD_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdSubReal -> Opcode.SUB_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdMulReal -> Opcode.MUL_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdDivReal -> Opcode.DIV_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdNegReal -> Opcode.NEG_REAL to intArrayOf(cmd.src, cmd.dst)
-            is CmdAndInt -> Opcode.AND_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdOrInt -> Opcode.OR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdXorInt -> Opcode.XOR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdShlInt -> Opcode.SHL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdShrInt -> Opcode.SHR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdUshrInt -> Opcode.USHR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdInvInt -> Opcode.INV_INT to intArrayOf(cmd.src, cmd.dst)
-            is CmdCmpEqInt -> Opcode.CMP_EQ_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpEqIntLocal -> Opcode.CMP_EQ_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdCmpNeqInt -> Opcode.CMP_NEQ_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpNeqIntLocal -> Opcode.CMP_NEQ_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdCmpLtInt -> Opcode.CMP_LT_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLtIntLocal -> Opcode.CMP_LT_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdCmpLteInt -> Opcode.CMP_LTE_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLteIntLocal -> Opcode.CMP_LTE_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdCmpGtInt -> Opcode.CMP_GT_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGtIntLocal -> Opcode.CMP_GT_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdCmpGteInt -> Opcode.CMP_GTE_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGteIntLocal -> Opcode.CMP_GTE_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
-            is CmdCmpEqReal -> Opcode.CMP_EQ_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpNeqReal -> Opcode.CMP_NEQ_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLtReal -> Opcode.CMP_LT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLteReal -> Opcode.CMP_LTE_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGtReal -> Opcode.CMP_GT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGteReal -> Opcode.CMP_GTE_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpEqBool -> Opcode.CMP_EQ_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpNeqBool -> Opcode.CMP_NEQ_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpEqIntReal -> Opcode.CMP_EQ_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpEqRealInt -> Opcode.CMP_EQ_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLtIntReal -> Opcode.CMP_LT_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLtRealInt -> Opcode.CMP_LT_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLteIntReal -> Opcode.CMP_LTE_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLteRealInt -> Opcode.CMP_LTE_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGtIntReal -> Opcode.CMP_GT_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGtRealInt -> Opcode.CMP_GT_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGteIntReal -> Opcode.CMP_GTE_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGteRealInt -> Opcode.CMP_GTE_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpNeqIntReal -> Opcode.CMP_NEQ_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpNeqRealInt -> Opcode.CMP_NEQ_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpEqObj -> Opcode.CMP_EQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpNeqObj -> Opcode.CMP_NEQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpRefEqObj -> Opcode.CMP_REF_EQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpRefNeqObj -> Opcode.CMP_REF_NEQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdNotBool -> Opcode.NOT_BOOL to intArrayOf(cmd.src, cmd.dst)
-            is CmdAndBool -> Opcode.AND_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdOrBool -> Opcode.OR_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLtObj -> Opcode.CMP_LT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpLteObj -> Opcode.CMP_LTE_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGtObj -> Opcode.CMP_GT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdCmpGteObj -> Opcode.CMP_GTE_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdAddObj -> Opcode.ADD_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdSubObj -> Opcode.SUB_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdMulObj -> Opcode.MUL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdDivObj -> Opcode.DIV_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdModObj -> Opcode.MOD_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
-            is CmdContainsObj -> Opcode.CONTAINS_OBJ to intArrayOf(cmd.target, cmd.value, cmd.dst)
-            is CmdAssignOpObj -> Opcode.ASSIGN_OP_OBJ to intArrayOf(cmd.opId, cmd.targetSlot, cmd.valueSlot, cmd.dst, cmd.nameId)
-            is CmdJmp -> Opcode.JMP to intArrayOf(cmd.target)
-            is CmdJmpIfTrue -> Opcode.JMP_IF_TRUE to intArrayOf(cmd.cond, cmd.target)
-            is CmdJmpIfFalse -> Opcode.JMP_IF_FALSE to intArrayOf(cmd.cond, cmd.target)
-            is CmdRet -> Opcode.RET to intArrayOf(cmd.slot)
-            is CmdRetLabel -> Opcode.RET_LABEL to intArrayOf(cmd.labelId, cmd.slot)
-            is CmdRetVoid -> Opcode.RET_VOID to intArrayOf()
-            is CmdThrow -> Opcode.THROW to intArrayOf(cmd.posId, cmd.slot)
-            is CmdPushScope -> Opcode.PUSH_SCOPE to intArrayOf(cmd.planId)
-            is CmdPopScope -> Opcode.POP_SCOPE to intArrayOf()
-            is CmdPushSlotPlan -> Opcode.PUSH_SLOT_PLAN to intArrayOf(cmd.planId)
-            is CmdPopSlotPlan -> Opcode.POP_SLOT_PLAN to intArrayOf()
-            is CmdDeclLocal -> Opcode.DECL_LOCAL to intArrayOf(cmd.constId, cmd.slot)
-            is CmdDeclExtProperty -> Opcode.DECL_EXT_PROPERTY to intArrayOf(cmd.constId, cmd.slot)
-            is CmdCallDirect -> Opcode.CALL_DIRECT to intArrayOf(cmd.id, cmd.argBase, cmd.argCount, cmd.dst)
-            is CmdCallMemberSlot -> Opcode.CALL_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.methodId, cmd.argBase, cmd.argCount, cmd.dst)
-            is CmdCallSlot -> Opcode.CALL_SLOT to intArrayOf(cmd.calleeSlot, cmd.argBase, cmd.argCount, cmd.dst)
-            is CmdGetIndex -> Opcode.GET_INDEX to intArrayOf(cmd.targetSlot, cmd.indexSlot, cmd.dst)
-            is CmdSetIndex -> Opcode.SET_INDEX to intArrayOf(cmd.targetSlot, cmd.indexSlot, cmd.valueSlot)
-            is CmdListLiteral -> Opcode.LIST_LITERAL to intArrayOf(cmd.planId, cmd.baseSlot, cmd.count, cmd.dst)
-            is CmdGetMemberSlot -> Opcode.GET_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.fieldId, cmd.methodId, cmd.dst)
-            is CmdSetMemberSlot -> Opcode.SET_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.fieldId, cmd.methodId, cmd.valueSlot)
-            is CmdIterPush -> Opcode.ITER_PUSH to intArrayOf(cmd.iterSlot)
-            is CmdIterPop -> Opcode.ITER_POP to intArrayOf()
-            is CmdIterCancel -> Opcode.ITER_CANCEL to intArrayOf()
-            else -> error("Unsupported cmd in disassembler: ${cmd::class.simpleName}")
-        }
-    }
-
-    private enum class OperandKind {
-        SLOT,
-        ADDR,
-        CONST,
-        IP,
-        COUNT,
-        ID,
-    }
-
-    private fun operandKinds(op: Opcode): List<OperandKind> {
-        return when (op) {
-            Opcode.NOP, Opcode.RET_VOID, Opcode.POP_SCOPE, Opcode.POP_SLOT_PLAN,
-            Opcode.ITER_POP, Opcode.ITER_CANCEL -> emptyList()
-            Opcode.MOVE_OBJ, Opcode.MOVE_INT, Opcode.MOVE_REAL, Opcode.MOVE_BOOL, Opcode.BOX_OBJ,
-            Opcode.INT_TO_REAL, Opcode.REAL_TO_INT, Opcode.BOOL_TO_INT, Opcode.INT_TO_BOOL,
-            Opcode.NEG_INT, Opcode.NEG_REAL, Opcode.NOT_BOOL, Opcode.INV_INT ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.OBJ_TO_BOOL, Opcode.ASSERT_IS ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.CHECK_IS ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.RANGE_INT_BOUNDS, Opcode.MAKE_RANGE ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.RET_LABEL, Opcode.THROW ->
-                listOf(OperandKind.CONST, OperandKind.SLOT)
-            Opcode.RESOLVE_SCOPE_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.ADDR)
-            Opcode.LOAD_OBJ_ADDR, Opcode.LOAD_INT_ADDR, Opcode.LOAD_REAL_ADDR, Opcode.LOAD_BOOL_ADDR ->
-                listOf(OperandKind.ADDR, OperandKind.SLOT)
-            Opcode.STORE_OBJ_ADDR, Opcode.STORE_INT_ADDR, Opcode.STORE_REAL_ADDR, Opcode.STORE_BOOL_ADDR ->
-                listOf(OperandKind.SLOT, OperandKind.ADDR)
-            Opcode.CONST_NULL ->
-                listOf(OperandKind.SLOT)
-            Opcode.CONST_OBJ, Opcode.CONST_INT, Opcode.CONST_REAL, Opcode.CONST_BOOL, Opcode.MAKE_VALUE_FN ->
-                listOf(OperandKind.CONST, OperandKind.SLOT)
-            Opcode.PUSH_SCOPE, Opcode.PUSH_SLOT_PLAN ->
-                listOf(OperandKind.CONST)
-            Opcode.DECL_LOCAL, Opcode.DECL_EXT_PROPERTY ->
-                listOf(OperandKind.CONST, OperandKind.SLOT)
-            Opcode.ADD_INT, Opcode.SUB_INT, Opcode.MUL_INT, Opcode.DIV_INT, Opcode.MOD_INT,
-            Opcode.ADD_REAL, Opcode.SUB_REAL, Opcode.MUL_REAL, Opcode.DIV_REAL,
-            Opcode.AND_INT, Opcode.OR_INT, Opcode.XOR_INT, Opcode.SHL_INT, Opcode.SHR_INT, Opcode.USHR_INT,
-            Opcode.CMP_EQ_INT, Opcode.CMP_NEQ_INT, Opcode.CMP_LT_INT, Opcode.CMP_LTE_INT,
-            Opcode.CMP_GT_INT, Opcode.CMP_GTE_INT,
-            Opcode.CMP_EQ_REAL, Opcode.CMP_NEQ_REAL, Opcode.CMP_LT_REAL, Opcode.CMP_LTE_REAL,
-            Opcode.CMP_GT_REAL, Opcode.CMP_GTE_REAL,
-            Opcode.CMP_EQ_BOOL, Opcode.CMP_NEQ_BOOL,
-            Opcode.CMP_EQ_INT_REAL, Opcode.CMP_EQ_REAL_INT, Opcode.CMP_LT_INT_REAL, Opcode.CMP_LT_REAL_INT,
-            Opcode.CMP_LTE_INT_REAL, Opcode.CMP_LTE_REAL_INT, Opcode.CMP_GT_INT_REAL, Opcode.CMP_GT_REAL_INT,
-            Opcode.CMP_GTE_INT_REAL, Opcode.CMP_GTE_REAL_INT, Opcode.CMP_NEQ_INT_REAL, Opcode.CMP_NEQ_REAL_INT,
-            Opcode.CMP_EQ_OBJ, Opcode.CMP_NEQ_OBJ, Opcode.CMP_REF_EQ_OBJ, Opcode.CMP_REF_NEQ_OBJ,
-            Opcode.CMP_LT_OBJ, Opcode.CMP_LTE_OBJ, Opcode.CMP_GT_OBJ, Opcode.CMP_GTE_OBJ,
-            Opcode.ADD_OBJ, Opcode.SUB_OBJ, Opcode.MUL_OBJ, Opcode.DIV_OBJ, Opcode.MOD_OBJ, Opcode.CONTAINS_OBJ,
-            Opcode.AND_BOOL, Opcode.OR_BOOL ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.ASSIGN_OP_OBJ ->
-                listOf(OperandKind.ID, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.CONST)
-            Opcode.INC_INT, Opcode.DEC_INT, Opcode.RET, Opcode.ITER_PUSH, Opcode.LOAD_THIS ->
-                listOf(OperandKind.SLOT)
-            Opcode.LOAD_THIS_VARIANT ->
-                listOf(OperandKind.ID, OperandKind.SLOT)
-            Opcode.JMP ->
-                listOf(OperandKind.IP)
-            Opcode.JMP_IF_TRUE, Opcode.JMP_IF_FALSE ->
-                listOf(OperandKind.SLOT, OperandKind.IP)
-            Opcode.CALL_DIRECT ->
-                listOf(OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
-            Opcode.CALL_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
-            Opcode.CALL_MEMBER_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
-            Opcode.GET_INDEX ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.SET_INDEX ->
-                listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
-            Opcode.LIST_LITERAL ->
-                listOf(OperandKind.CONST, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
-            Opcode.GET_MEMBER_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT)
-            Opcode.SET_MEMBER_SLOT ->
-                listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT)
-        }
-    }
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/CmdFunction.kt

@@ -1,41 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.bytecode
-
-data class CmdFunction(
-    val name: String,
-    val localCount: Int,
-    val addrCount: Int,
-    val returnLabels: Set<String>,
-    val scopeSlotCount: Int,
-    val scopeSlotIndices: IntArray,
-    val scopeSlotNames: Array<String?>,
-    val scopeSlotIsModule: BooleanArray,
-    val localSlotNames: Array<String?>,
-    val localSlotMutables: BooleanArray,
-    val constants: List<BytecodeConst>,
-    val cmds: Array<Cmd>,
-) {
-    init {
-        require(scopeSlotIndices.size == scopeSlotCount) { "scopeSlotIndices size mismatch" }
-        require(scopeSlotNames.size == scopeSlotCount) { "scopeSlotNames size mismatch" }
-        require(scopeSlotIsModule.size == scopeSlotCount) { "scopeSlotIsModule size mismatch" }
-        require(localSlotNames.size == localSlotMutables.size) { "localSlot metadata size mismatch" }
-        require(localSlotNames.size <= localCount) { "localSlotNames exceed localCount" }
-        require(addrCount >= 0) { "addrCount must be non-negative" }
-    }
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/Opcode.kt

@@ -1,157 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.bytecode
-
-enum class Opcode(val code: Int) {
-    NOP(0x00),
-    MOVE_OBJ(0x01),
-    MOVE_INT(0x02),
-    MOVE_REAL(0x03),
-    MOVE_BOOL(0x04),
-    CONST_OBJ(0x05),
-    CONST_INT(0x06),
-    CONST_REAL(0x07),
-    CONST_BOOL(0x08),
-    CONST_NULL(0x09),
-    BOX_OBJ(0x0A),
-    RANGE_INT_BOUNDS(0x0B),
-    MAKE_RANGE(0x0C),
-    LOAD_THIS(0x0D),
-    MAKE_VALUE_FN(0x0E),
-    LOAD_THIS_VARIANT(0x0F),
-
-    INT_TO_REAL(0x10),
-    REAL_TO_INT(0x11),
-    BOOL_TO_INT(0x12),
-    INT_TO_BOOL(0x13),
-    OBJ_TO_BOOL(0x14),
-    CHECK_IS(0x15),
-    ASSERT_IS(0x16),
-
-    ADD_INT(0x20),
-    SUB_INT(0x21),
-    MUL_INT(0x22),
-    DIV_INT(0x23),
-    MOD_INT(0x24),
-    NEG_INT(0x25),
-    INC_INT(0x26),
-    DEC_INT(0x27),
-
-    ADD_REAL(0x30),
-    SUB_REAL(0x31),
-    MUL_REAL(0x32),
-    DIV_REAL(0x33),
-    NEG_REAL(0x34),
-
-    AND_INT(0x40),
-    OR_INT(0x41),
-    XOR_INT(0x42),
-    SHL_INT(0x43),
-    SHR_INT(0x44),
-    USHR_INT(0x45),
-    INV_INT(0x46),
-
-    CMP_EQ_INT(0x50),
-    CMP_NEQ_INT(0x51),
-    CMP_LT_INT(0x52),
-    CMP_LTE_INT(0x53),
-    CMP_GT_INT(0x54),
-    CMP_GTE_INT(0x55),
-    CMP_EQ_REAL(0x56),
-    CMP_NEQ_REAL(0x57),
-    CMP_LT_REAL(0x58),
-    CMP_LTE_REAL(0x59),
-    CMP_GT_REAL(0x5A),
-    CMP_GTE_REAL(0x5B),
-    CMP_EQ_BOOL(0x5C),
-    CMP_NEQ_BOOL(0x5D),
-
-    CMP_EQ_INT_REAL(0x60),
-    CMP_EQ_REAL_INT(0x61),
-    CMP_LT_INT_REAL(0x62),
-    CMP_LT_REAL_INT(0x63),
-    CMP_LTE_INT_REAL(0x64),
-    CMP_LTE_REAL_INT(0x65),
-    CMP_GT_INT_REAL(0x66),
-    CMP_GT_REAL_INT(0x67),
-    CMP_GTE_INT_REAL(0x68),
-    CMP_GTE_REAL_INT(0x69),
-    CMP_NEQ_INT_REAL(0x6A),
-    CMP_NEQ_REAL_INT(0x6B),
-    CMP_EQ_OBJ(0x6C),
-    CMP_NEQ_OBJ(0x6D),
-    CMP_REF_EQ_OBJ(0x6E),
-    CMP_REF_NEQ_OBJ(0x6F),
-
-    NOT_BOOL(0x70),
-    AND_BOOL(0x71),
-    OR_BOOL(0x72),
-    CMP_LT_OBJ(0x73),
-    CMP_LTE_OBJ(0x74),
-    CMP_GT_OBJ(0x75),
-    CMP_GTE_OBJ(0x76),
-    ADD_OBJ(0x77),
-    SUB_OBJ(0x78),
-    MUL_OBJ(0x79),
-    DIV_OBJ(0x7A),
-    MOD_OBJ(0x7B),
-    CONTAINS_OBJ(0x7C),
-    ASSIGN_OP_OBJ(0x7D),
-
-    JMP(0x80),
-    JMP_IF_TRUE(0x81),
-    JMP_IF_FALSE(0x82),
-    RET(0x83),
-    RET_VOID(0x84),
-    RET_LABEL(0xBA),
-    PUSH_SCOPE(0x85),
-    POP_SCOPE(0x86),
-    PUSH_SLOT_PLAN(0x87),
-    POP_SLOT_PLAN(0x88),
-    DECL_LOCAL(0x89),
-    DECL_EXT_PROPERTY(0x8A),
-
-    CALL_DIRECT(0x90),
-    CALL_MEMBER_SLOT(0x92),
-    CALL_SLOT(0x93),
-
-    GET_INDEX(0xA2),
-    SET_INDEX(0xA3),
-    LIST_LITERAL(0xA5),
-    GET_MEMBER_SLOT(0xA8),
-    SET_MEMBER_SLOT(0xA9),
-
-    RESOLVE_SCOPE_SLOT(0xB1),
-    LOAD_OBJ_ADDR(0xB2),
-    STORE_OBJ_ADDR(0xB3),
-    LOAD_INT_ADDR(0xB4),
-    STORE_INT_ADDR(0xB5),
-    LOAD_REAL_ADDR(0xB6),
-    STORE_REAL_ADDR(0xB7),
-    LOAD_BOOL_ADDR(0xB8),
-    STORE_BOOL_ADDR(0xB9),
-    THROW(0xBB),
-    ITER_PUSH(0xBF),
-    ITER_POP(0xC0),
-    ITER_CANCEL(0xC1),
-    ;
-
-    companion object {
-        private val byCode: Map<Int, Opcode> = values().associateBy { it.code }
-        fun fromCode(code: Int): Opcode? = byCode[code]
-    }
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/SlotType.kt

@@ -1,25 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.bytecode
-
-enum class SlotType(val code: Byte) {
-    UNKNOWN(0),
-    OBJ(1),
-    INT(2),
-    REAL(3),
-    BOOL(4),
-}

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

@@ -1025,8 +1025,6 @@ object DocLookupUtils {
         is MiniGenericType -> simpleClassNameOf(t.base)
         is MiniFunctionType -> null
         is MiniTypeVar -> null
-        is MiniTypeUnion -> null
-        is MiniTypeIntersection -> null
     }
 
     fun typeOf(t: MiniTypeRef?): String = when (t) {
@@ -1037,8 +1035,6 @@ object DocLookupUtils {
             r + "(" + t.params.joinToString(", ") { typeOf(it) } + ") -> " + typeOf(t.returnType) + (if (t.nullable) "?" else "")
         }
         is MiniTypeVar -> t.name + (if (t.nullable) "?" else "")
-        is MiniTypeUnion -> t.options.joinToString(" | ") { typeOf(it) } + (if (t.nullable) "?" else "")
-        is MiniTypeIntersection -> t.options.joinToString(" & ") { typeOf(it) } + (if (t.nullable) "?" else "")
         null -> ""
     }
 

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

@@ -39,11 +39,10 @@ inline fun <reified T : Obj> Scope.addFnDoc(
     returns: TypeDoc? = null,
     tags: Map<String, List<String>> = emptyMap(),
     moduleName: String? = null,
-    callSignature: net.sergeych.lyng.CallSignature? = null,
     crossinline fn: suspend Scope.() -> T
 ) {
     // Register runtime function(s)
-    addFn(*names, callSignature = callSignature) { fn() }
+    addFn(*names) { fn() }
     // Determine module
     val mod = moduleName ?: findModuleNameOrUnknown()
     // Register docs once per name

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

@@ -150,18 +150,6 @@ data class MiniTypeVar(
     val nullable: Boolean
 ) : MiniTypeRef
 
-data class MiniTypeUnion(
-    override val range: MiniRange,
-    val options: List<MiniTypeRef>,
-    val nullable: Boolean
-) : MiniTypeRef
-
-data class MiniTypeIntersection(
-    override val range: MiniRange,
-    val options: List<MiniTypeRef>,
-    val nullable: Boolean
-) : MiniTypeRef
-
 // Script and declarations (lean subset; can be extended later)
 sealed interface MiniNamedDecl : MiniNode {
     val name: String

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

@@ -124,7 +124,17 @@ open class Obj {
             }
         }
 
-        // 2. Root object fallback
+        // 2. Extensions in scope
+        val extension = scope.findExtension(objClass, name)
+        if (extension != null) {
+            if (extension.type == ObjRecord.Type.Property) {
+                if (args.isEmpty()) return (extension.value as ObjProperty).callGetter(scope, this, extension.declaringClass)
+            } else if (extension.type != ObjRecord.Type.Delegated) {
+                return extension.value.invoke(scope, this, args)
+            }
+        }
+
+        // 3. Root object fallback
         for (cls in objClass.mro) {
             if (cls.className == "Obj") {
                 cls.members[name]?.let { rec ->
@@ -171,7 +181,7 @@ open class Obj {
 
     open suspend fun equals(scope: Scope, other: Obj): Boolean {
         if (other === this) return true
-        val m = objClass.getInstanceMemberOrNull("equals")
+        val m = objClass.getInstanceMemberOrNull("equals") ?: scope.findExtension(objClass, "equals")
         if (m != null) {
             return invokeInstanceMethod(scope, "equals", Arguments(other)).toBool()
         }
@@ -365,7 +375,7 @@ open class Obj {
      * to generate it as 'this = this + other', reassigning its variable
      */
     open suspend fun plusAssign(scope: Scope, other: Obj): Obj? {
-        val m = objClass.getInstanceMemberOrNull("plusAssign")
+        val m = objClass.getInstanceMemberOrNull("plusAssign") ?: scope.findExtension(objClass, "plusAssign")
         return if (m != null) {
             invokeInstanceMethod(scope, "plusAssign", Arguments(other))
         } else null
@@ -375,28 +385,28 @@ open class Obj {
      * `-=` operations, see [plusAssign]
      */
     open suspend fun minusAssign(scope: Scope, other: Obj): Obj? {
-        val m = objClass.getInstanceMemberOrNull("minusAssign")
+        val m = objClass.getInstanceMemberOrNull("minusAssign") ?: scope.findExtension(objClass, "minusAssign")
         return if (m != null) {
             invokeInstanceMethod(scope, "minusAssign", Arguments(other))
         } else null
     }
 
     open suspend fun mulAssign(scope: Scope, other: Obj): Obj? {
-        val m = objClass.getInstanceMemberOrNull("mulAssign")
+        val m = objClass.getInstanceMemberOrNull("mulAssign") ?: scope.findExtension(objClass, "mulAssign")
         return if (m != null) {
             invokeInstanceMethod(scope, "mulAssign", Arguments(other))
         } else null
     }
 
     open suspend fun divAssign(scope: Scope, other: Obj): Obj? {
-        val m = objClass.getInstanceMemberOrNull("divAssign")
+        val m = objClass.getInstanceMemberOrNull("divAssign") ?: scope.findExtension(objClass, "divAssign")
         return if (m != null) {
             invokeInstanceMethod(scope, "divAssign", Arguments(other))
         } else null
     }
 
     open suspend fun modAssign(scope: Scope, other: Obj): Obj? {
-        val m = objClass.getInstanceMemberOrNull("modAssign")
+        val m = objClass.getInstanceMemberOrNull("modAssign") ?: scope.findExtension(objClass, "modAssign")
         return if (m != null) {
             invokeInstanceMethod(scope, "modAssign", Arguments(other))
         } else null
@@ -457,7 +467,16 @@ open class Obj {
             }
         }
 
-        // 2. Root fallback
+        // 2. Extensions
+        val extension = scope.findExtension(objClass, name)
+        if (extension != null) {
+            val resolved = resolveRecord(scope, extension, name, extension.declaringClass)
+            if (resolved.type == ObjRecord.Type.Fun && resolved.value is Statement)
+                return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, extension.declaringClass))
+            return resolved
+        }
+
+        // 3. Root fallback
         for (cls in objClass.mro) {
             if (cls.className == "Obj") {
                 cls.members[name]?.let { rec ->
@@ -539,7 +558,11 @@ open class Obj {
                 }
             }
         }
-        // 2. Root fallback
+        // 2. Extensions
+        if (field == null) {
+            field = scope.findExtension(objClass, name)
+        }
+        // 3. Root fallback
         if (field == null) {
             for (cls in objClass.mro) {
                 if (cls.className == "Obj") {
@@ -702,8 +725,7 @@ open class Obj {
                 (thisObj as? ObjInstance)?.let {
                     body.callOn(ApplyScope(this, it.instanceScope))
                 } ?: run {
-                    val appliedScope = createChildScope(newThisObj = thisObj)
+                    body.callOn(this)
-                    body.callOn(ApplyScope(this, appliedScope))
                 }
                 thisObj
             }

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

@@ -118,13 +118,9 @@ open class ObjClass(
 
     /**
      * Map of public member names to their effective storage keys in instanceScope.objects.
-     * Cached and invalidated by layoutVersion to reflect newly added members.
+     * This is pre-calculated to avoid MRO traversal and string concatenation during common access.
      */
-    private var publicMemberResolutionVersion: Int = -1
+    val publicMemberResolution: Map<String, String> by lazy {
-    private var publicMemberResolutionCache: Map<String, String> = emptyMap()
-    val publicMemberResolution: Map<String, String>
-        get() {
-            if (publicMemberResolutionVersion == layoutVersion) return publicMemberResolutionCache
         val res = mutableMapOf<String, String>()
         // Traverse MRO in REVERSED order so that child classes override parent classes in the map.
         for (cls in mro.reversed()) {
@@ -142,9 +138,7 @@ open class ObjClass(
                 }
             }
         }
-            publicMemberResolutionCache = res
+        res
-            publicMemberResolutionVersion = layoutVersion
-            return res
     }
 
     val classNameObj by lazy { ObjString(className) }
@@ -275,11 +269,6 @@ open class ObjClass(
     internal data class FieldSlot(val slot: Int, val record: ObjRecord)
     internal data class ResolvedMember(val record: ObjRecord, val declaringClass: ObjClass)
     internal data class MethodSlot(val slot: Int, val record: ObjRecord)
-    private var nextFieldId: Int = 0
-    private var nextMethodId: Int = 0
-    private val fieldIdMap: MutableMap<String, Int> = mutableMapOf()
-    private val methodIdMap: MutableMap<String, Int> = mutableMapOf()
-    private var methodIdSeeded: Boolean = false
     private var fieldSlotLayoutVersion: Int = -1
     private var fieldSlotMap: Map<String, FieldSlot> = emptyMap()
     private var fieldSlotCount: Int = 0
@@ -292,29 +281,19 @@ open class ObjClass(
     private fun ensureFieldSlots(): Map<String, FieldSlot> {
         if (fieldSlotLayoutVersion == layoutVersion) return fieldSlotMap
         val res = mutableMapOf<String, FieldSlot>()
-        var maxId = -1
+        var idx = 0
         for (cls in mro) {
             for ((name, rec) in cls.members) {
                 if (rec.isAbstract) continue
                 if (rec.type != ObjRecord.Type.Field && rec.type != ObjRecord.Type.ConstructorField) continue
                 val key = cls.mangledName(name)
                 if (res.containsKey(key)) continue
-                val fieldId = rec.fieldId ?: cls.assignFieldId(name, rec)
+                res[key] = FieldSlot(idx, rec)
-                res[key] = FieldSlot(fieldId, rec)
+                idx += 1
-                if (fieldId > maxId) maxId = fieldId
-            }
-            cls.classScope?.objects?.forEach { (name, rec) ->
-                if (rec.isAbstract) return@forEach
-                if (rec.type != ObjRecord.Type.Field && rec.type != ObjRecord.Type.ConstructorField) return@forEach
-                val key = cls.mangledName(name)
-                if (res.containsKey(key)) return@forEach
-                val fieldId = rec.fieldId ?: cls.assignFieldId(name, rec)
-                res[key] = FieldSlot(fieldId, rec)
-                if (fieldId > maxId) maxId = fieldId
             }
         }
         fieldSlotMap = res
-        fieldSlotCount = maxId + 1
+        fieldSlotCount = idx
         fieldSlotLayoutVersion = layoutVersion
         return fieldSlotMap
     }
@@ -323,6 +302,7 @@ open class ObjClass(
         if (instanceMemberLayoutVersion == layoutVersion) return instanceMemberCache
         val res = mutableMapOf<String, ResolvedMember>()
         for (cls in mro) {
+            if (cls.className == "Obj") break
             for ((name, rec) in cls.members) {
                 if (rec.isAbstract) continue
                 if (res.containsKey(name)) continue
@@ -344,7 +324,7 @@ open class ObjClass(
     private fun ensureMethodSlots(): Map<String, MethodSlot> {
         if (methodSlotLayoutVersion == layoutVersion) return methodSlotMap
         val res = mutableMapOf<String, MethodSlot>()
-        var maxId = -1
+        var idx = 0
         for (cls in mro) {
             if (cls.className == "Obj") break
             for ((name, rec) in cls.members) {
@@ -357,9 +337,8 @@ open class ObjClass(
                 }
                 val key = if (rec.visibility == Visibility.Private || rec.type == ObjRecord.Type.Delegated) cls.mangledName(name) else name
                 if (res.containsKey(key)) continue
-                val methodId = rec.methodId ?: cls.assignMethodId(name, rec)
+                res[key] = MethodSlot(idx, rec)
-                res[key] = MethodSlot(methodId, rec)
+                idx += 1
-                if (methodId > maxId) maxId = methodId
             }
             cls.classScope?.objects?.forEach { (name, rec) ->
                 if (rec.isAbstract) return@forEach
@@ -368,13 +347,12 @@ open class ObjClass(
                     rec.type != ObjRecord.Type.Property) return@forEach
                 val key = if (rec.visibility == Visibility.Private || rec.type == ObjRecord.Type.Delegated) cls.mangledName(name) else name
                 if (res.containsKey(key)) return@forEach
-                val methodId = rec.methodId ?: cls.assignMethodId(name, rec)
+                res[key] = MethodSlot(idx, rec)
-                res[key] = MethodSlot(methodId, rec)
+                idx += 1
-                if (methodId > maxId) maxId = methodId
             }
         }
         methodSlotMap = res
-        methodSlotCount = maxId + 1
+        methodSlotCount = idx
         methodSlotLayoutVersion = layoutVersion
         return methodSlotMap
     }
@@ -390,10 +368,6 @@ open class ObjClass(
     }
 
     internal fun fieldSlotMap(): Map<String, FieldSlot> = ensureFieldSlots()
-    internal fun fieldRecordForId(fieldId: Int): ObjRecord? {
-        ensureFieldSlots()
-        return fieldSlotMap.values.firstOrNull { it.slot == fieldId }?.record
-    }
     internal fun resolveInstanceMember(name: String): ResolvedMember? = ensureInstanceMemberCache()[name]
     internal fun methodSlotCount(): Int {
         ensureMethodSlots()
@@ -404,117 +378,6 @@ open class ObjClass(
         return methodSlotMap[key]
     }
     internal fun methodSlotMap(): Map<String, MethodSlot> = ensureMethodSlots()
-    internal fun methodRecordForId(methodId: Int): ObjRecord? {
-        ensureMethodSlots()
-        methodSlotMap.values.firstOrNull { it.slot == methodId }?.record?.let { return it }
-        // Fallback to scanning the MRO in case a parent method id was added after slot cache creation.
-        for (cls in mro) {
-            for ((_, rec) in cls.members) {
-                if (rec.methodId == methodId) return rec
-            }
-            cls.classScope?.objects?.forEach { (_, rec) ->
-                if (rec.methodId == methodId) return rec
-            }
-        }
-        return null
-    }
-
-    internal fun instanceFieldIdMap(): Map<String, Int> {
-        val result = mutableMapOf<String, Int>()
-        for (cls in mro) {
-            if (cls.className == "Obj") break
-            for ((name, rec) in cls.members) {
-                if (rec.isAbstract) continue
-                if (rec.type != ObjRecord.Type.Field && rec.type != ObjRecord.Type.ConstructorField) continue
-                if (rec.visibility == Visibility.Private) continue
-                val id = rec.fieldId ?: cls.assignFieldId(name, rec)
-                if (!result.containsKey(name)) result[name] = id
-            }
-            cls.classScope?.objects?.forEach { (name, rec) ->
-                if (rec.isAbstract) return@forEach
-                if (rec.type != ObjRecord.Type.Field && rec.type != ObjRecord.Type.ConstructorField) return@forEach
-                if (rec.visibility == Visibility.Private) return@forEach
-                val id = rec.fieldId ?: cls.assignFieldId(name, rec)
-                if (!result.containsKey(name)) result[name] = id
-            }
-        }
-        return result
-    }
-
-    internal fun instanceMethodIdMap(includeAbstract: Boolean = false): Map<String, Int> {
-        val result = mutableMapOf<String, Int>()
-        for (cls in mro) {
-            for ((name, rec) in cls.members) {
-                if (!includeAbstract && rec.isAbstract) continue
-                if (rec.visibility == Visibility.Private) continue
-                if (rec.type != ObjRecord.Type.Fun &&
-                    rec.type != ObjRecord.Type.Property &&
-                    rec.type != ObjRecord.Type.Delegated) continue
-                val id = rec.methodId ?: cls.assignMethodId(name, rec)
-                if (!result.containsKey(name)) result[name] = id
-            }
-            cls.classScope?.objects?.forEach { (name, rec) ->
-                if (!includeAbstract && rec.isAbstract) return@forEach
-                if (rec.visibility == Visibility.Private) return@forEach
-                if (rec.type != ObjRecord.Type.Fun &&
-                    rec.type != ObjRecord.Type.Property &&
-                    rec.type != ObjRecord.Type.Delegated) return@forEach
-                val id = rec.methodId ?: cls.assignMethodId(name, rec)
-                if (!result.containsKey(name)) result[name] = id
-            }
-        }
-        return result
-    }
-
-    private fun assignFieldId(name: String, rec: ObjRecord): Int {
-        val existingId = rec.fieldId
-        if (existingId != null) {
-            fieldIdMap[name] = existingId
-            return existingId
-        }
-        val id = fieldIdMap.getOrPut(name) { nextFieldId++ }
-        return id
-    }
-
-    private fun assignMethodId(name: String, rec: ObjRecord): Int {
-        ensureMethodIdSeeded()
-        val existingId = rec.methodId
-        if (existingId != null) {
-            methodIdMap[name] = existingId
-            return existingId
-        }
-        val id = methodIdMap.getOrPut(name) { nextMethodId++ }
-        return id
-    }
-
-    private fun ensureMethodIdSeeded() {
-        if (methodIdSeeded) return
-        var maxId = -1
-        for (cls in mroParents) {
-            for ((name, rec) in cls.members) {
-                if (rec.type != ObjRecord.Type.Fun &&
-                    rec.type != ObjRecord.Type.Property &&
-                    rec.type != ObjRecord.Type.Delegated
-                ) continue
-                val id = rec.methodId ?: cls.assignMethodId(name, rec)
-                if (!methodIdMap.containsKey(name)) methodIdMap[name] = id
-                if (id > maxId) maxId = id
-            }
-            cls.classScope?.objects?.forEach { (name, rec) ->
-                if (rec.type != ObjRecord.Type.Fun &&
-                    rec.type != ObjRecord.Type.Property &&
-                    rec.type != ObjRecord.Type.Delegated
-                ) return@forEach
-                val id = rec.methodId ?: cls.assignMethodId(name, rec)
-                if (!methodIdMap.containsKey(name)) methodIdMap[name] = id
-                if (id > maxId) maxId = id
-            }
-        }
-        if (nextMethodId <= maxId) {
-            nextMethodId = maxId + 1
-        }
-        methodIdSeeded = true
-    }
 
     override fun toString(): String = className
 
@@ -749,15 +612,12 @@ open class ObjClass(
         isOverride: Boolean = false,
         isTransient: Boolean = false,
         type: ObjRecord.Type = ObjRecord.Type.Field,
-        fieldId: Int? = null,
-        methodId: Int? = null,
     ): ObjRecord {
         // Validation of override rules: only for non-system declarations
-        var existing: ObjRecord? = null
-        var actualOverride = false
         if (pos != Pos.builtIn) {
             // Only consider TRUE instance members from ancestors for overrides
-            existing = getInstanceMemberOrNull(name, includeAbstract = true, includeStatic = false)
+            val existing = getInstanceMemberOrNull(name, includeAbstract = true, includeStatic = false)
+            var actualOverride = false
             if (existing != null && existing.declaringClass != this) {
                 // If the existing member is private in the ancestor, it's not visible for overriding.
                 // It should be treated as a new member in this class.
@@ -788,56 +648,6 @@ open class ObjClass(
             throw ScriptError(pos, "$name is already defined in $objClass")
         
         // Install/override in this class
-        val effectiveFieldId = if (type == ObjRecord.Type.Field || type == ObjRecord.Type.ConstructorField) {
-            fieldId ?: fieldIdMap[name]?.let { it } ?: run {
-                fieldIdMap[name] = nextFieldId
-                nextFieldId++
-                fieldIdMap[name]!!
-            }
-        } else {
-            fieldId
-        }
-        val inheritedCandidate = run {
-            var found: ObjRecord? = null
-            for (cls in mro) {
-                if (cls === this) continue
-                if (cls.className == "Obj") break
-                cls.members[name]?.let {
-                    found = it
-                    return@run found
-                }
-            }
-            found
-        }
-        if (type == ObjRecord.Type.Fun ||
-            type == ObjRecord.Type.Property ||
-            type == ObjRecord.Type.Delegated
-        ) {
-            ensureMethodIdSeeded()
-        }
-        val effectiveMethodId = if (type == ObjRecord.Type.Fun ||
-            type == ObjRecord.Type.Property ||
-            type == ObjRecord.Type.Delegated
-        ) {
-            val inherited = if (actualOverride) {
-                existing?.methodId
-            } else {
-                val candidate = inheritedCandidate
-                if (candidate != null &&
-                    candidate.declaringClass != this &&
-                    (candidate.visibility.isPublic || canAccessMember(candidate.visibility, candidate.declaringClass, this, name))
-                ) {
-                    candidate.methodId
-                } else null
-            }
-            methodId ?: inherited ?: methodIdMap[name]?.let { it } ?: run {
-                methodIdMap[name] = nextMethodId
-                nextMethodId++
-                methodIdMap[name]!!
-            }
-        } else {
-            methodId
-        }
         val rec = ObjRecord(
             initialValue, isMutable, visibility, writeVisibility, 
             declaringClass = declaringClass,
@@ -845,10 +655,7 @@ open class ObjClass(
             isClosed = isClosed,
             isOverride = isOverride,
             isTransient = isTransient,
-            type = type,
+            type = type
-            memberName = name,
-            fieldId = effectiveFieldId,
-            methodId = effectiveMethodId
         )
         members[name] = rec
         // Structural change: bump layout version for PIC invalidation
@@ -869,52 +676,13 @@ open class ObjClass(
         writeVisibility: Visibility? = null,
         pos: Pos = Pos.builtIn,
         isTransient: Boolean = false,
-        type: ObjRecord.Type = ObjRecord.Type.Field,
+        type: ObjRecord.Type = ObjRecord.Type.Field
-        fieldId: Int? = null,
-        methodId: Int? = null
     ): ObjRecord {
         initClassScope()
         val existing = classScope!!.objects[name]
         if (existing != null)
             throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
-        val effectiveFieldId = if (type == ObjRecord.Type.Field || type == ObjRecord.Type.ConstructorField) {
+        val rec = classScope!!.addItem(name, isMutable, initialValue, visibility, writeVisibility, recordType = type, isTransient = isTransient)
-            fieldId ?: fieldIdMap[name]?.let { it } ?: run {
-                fieldIdMap[name] = nextFieldId
-                nextFieldId++
-                fieldIdMap[name]!!
-            }
-        } else {
-            fieldId
-        }
-        if (type == ObjRecord.Type.Fun ||
-            type == ObjRecord.Type.Property ||
-            type == ObjRecord.Type.Delegated
-        ) {
-            ensureMethodIdSeeded()
-        }
-        val effectiveMethodId = if (type == ObjRecord.Type.Fun ||
-            type == ObjRecord.Type.Property ||
-            type == ObjRecord.Type.Delegated
-        ) {
-            methodId ?: methodIdMap[name]?.let { it } ?: run {
-                methodIdMap[name] = nextMethodId
-                nextMethodId++
-                methodIdMap[name]!!
-            }
-        } else {
-            methodId
-        }
-        val rec = classScope!!.addItem(
-            name,
-            isMutable,
-            initialValue,
-            visibility,
-            writeVisibility,
-            recordType = type,
-            isTransient = isTransient,
-            fieldId = effectiveFieldId,
-            methodId = effectiveMethodId
-        )
         // Structural change: bump layout version for PIC invalidation
         layoutVersion += 1
         return rec
@@ -930,15 +698,13 @@ open class ObjClass(
         isClosed: Boolean = false,
         isOverride: Boolean = false,
         pos: Pos = Pos.builtIn,
-        methodId: Int? = null,
         code: (suspend Scope.() -> Obj)? = null
     ) {
         val stmt = code?.let { statement { it() } } ?: ObjNull
         createField(
             name, stmt, isMutable, visibility, writeVisibility, pos, declaringClass,
             isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride,
-            type = ObjRecord.Type.Fun,
+            type = ObjRecord.Type.Fun
-            methodId = methodId
         )
     }
 
@@ -955,8 +721,7 @@ open class ObjClass(
         isClosed: Boolean = false,
         isOverride: Boolean = false,
         pos: Pos = Pos.builtIn,
-        prop: ObjProperty? = null,
+        prop: ObjProperty? = null
-        methodId: Int? = null
     ) {
         val g = getter?.let { statement { it() } }
         val s = setter?.let { statement { it(requiredArg(0)); ObjVoid } }
@@ -964,8 +729,7 @@ open class ObjClass(
         createField(
             name, finalProp, false, visibility, writeVisibility, pos, declaringClass,
             isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride,
-            type = ObjRecord.Type.Property,
+            type = ObjRecord.Type.Property
-            methodId = methodId
         )
     }
 

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

@@ -344,11 +344,7 @@ fun Obj.isLyngException(): Boolean = isInstanceOf("Exception")
  */
 suspend fun Obj.getLyngExceptionMessage(scope: Scope? = null): String {
     require(this.isLyngException())
-    val s = scope ?: when (this) {
+    val s = scope ?: Script.newScope()
-        is ObjException -> this.scope
-        is ObjInstance -> this.instanceScope
-        else -> Script.newScope()
-    }
     return invokeInstanceMethod(s, "message").toString(s).value
 }
 
@@ -365,25 +361,16 @@ suspend fun Obj.getLyngExceptionMessage(scope: Scope? = null): String {
  */
 suspend fun Obj.getLyngExceptionMessageWithStackTrace(scope: Scope? = null,showDetails:Boolean=true): String {
     require(this.isLyngException())
-    val s = scope ?: when (this) {
+    val s = scope ?: Script.newScope()
-        is ObjException -> this.scope
-        is ObjInstance -> this.instanceScope
-        else -> Script.newScope()
-    }
     val msg = getLyngExceptionMessage(s)
     val trace = getLyngExceptionStackTrace(s)
     var at = "unknown"
+//    var firstLine = true
     val stack = if (!trace.list.isEmpty()) {
         val first = trace.list[0]
         at = (first.readField(s, "at").value as ObjString).value
         "\n" + trace.list.map { "    at " + it.toString(s).value }.joinToString("\n")
-    } else {
+    } else ""
-        val pos = s.pos
-        if (pos.source.fileName.isNotEmpty() && pos.currentLine.isNotEmpty()) {
-            at = "${pos.source.fileName}:${pos.line + 1}:${pos.column + 1}"
-        }
-        ""
-    }
     return "$at: $msg$stack"
 }
 
@@ -409,16 +396,9 @@ suspend fun Obj.getLyngExceptionString(scope: Scope): String =
  * Rethrow this object as a Kotlin [ExecutionError] if it's an exception.
  */
 suspend fun Obj.raiseAsExecutionError(scope: Scope? = null): Nothing {
-    val sc = scope ?: when (this) {
+    if (this is ObjException) raise()
-        is ObjException -> this.scope
+    val sc = scope ?: Script.newScope()
-        is ObjInstance -> this.instanceScope
+    val msg = getLyngExceptionMessage(sc)
-        else -> Script.newScope()
+    val pos = (this as? ObjInstance)?.instanceScope?.pos ?: Pos.builtIn
-    }
-    val msg = getLyngExceptionMessageWithStackTrace(sc)
-    val pos = when (this) {
-        is ObjException -> this.scope.pos
-        is ObjInstance -> this.instanceScope.pos
-        else -> Pos.builtIn
-    }
     throw ExecutionError(this, pos, msg)
 }

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

@@ -1,68 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package net.sergeych.lyng.obj
-
-import net.sergeych.lyng.Arguments
-import net.sergeych.lyng.Scope
-
-class ObjExtensionMethodCallable(
-    private val name: String,
-    private val target: Obj,
-    private val declaringClass: ObjClass? = null
-) : Obj() {
-    override suspend fun callOn(scope: Scope): Obj {
-        val args = scope.args
-        if (args.isEmpty()) scope.raiseError("extension call $name requires receiver")
-        val receiver = args.first()
-        val rest = if (args.size <= 1) {
-            Arguments.EMPTY
-        } else {
-            Arguments(args.list.subList(1, args.size), args.tailBlockMode, args.named)
-        }
-        return target.invoke(scope, receiver, rest, declaringClass)
-    }
-}
-
-class ObjExtensionPropertyGetterCallable(
-    private val name: String,
-    private val property: ObjProperty,
-    private val declaringClass: ObjClass? = null
-) : Obj() {
-    override suspend fun callOn(scope: Scope): Obj {
-        val args = scope.args
-        if (args.isEmpty()) scope.raiseError("extension property $name requires receiver")
-        val receiver = args.first()
-        if (args.size > 1) scope.raiseError("extension property $name getter takes no arguments")
-        return property.callGetter(scope, receiver, declaringClass)
-    }
-}
-
-class ObjExtensionPropertySetterCallable(
-    private val name: String,
-    private val property: ObjProperty,
-    private val declaringClass: ObjClass? = null
-) : Obj() {
-    override suspend fun callOn(scope: Scope): Obj {
-        val args = scope.args
-        if (args.size < 2) scope.raiseError("extension property $name setter requires value")
-        val receiver = args[0]
-        val value = args[1]
-        property.callSetter(scope, receiver, value, declaringClass)
-        return ObjVoid
-    }
-}

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

@@ -81,8 +81,8 @@ private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChann
         } catch (x: ScriptFlowIsNoMoreCollected) {
             // premature flow closing, OK
         } catch (x: Exception) {
-            channel.close(x)
+            // Suppress stack traces in background producer to avoid noisy stderr during tests.
-            return@globalLaunch
+            // If needed, consider routing to a logger in the future.
         }
         channel.close()
     }
@@ -107,7 +107,9 @@ class ObjFlow(val producer: Statement, val scope: Scope) : Obj() {
             ) {
                 val objFlow = thisAs<ObjFlow>()
                 ObjFlowIterator(statement {
-                    objFlow.producer.execute(this)
+                    objFlow.producer.execute(
+                        ClosureScope(this, objFlow.scope)
+                    )
                 })
             }
         }
@@ -135,7 +137,6 @@ class ObjFlowIterator(val producer: Statement) : Obj() {
         // cold start:
         if (channel == null) channel = createLyngFlowInput(scope, producer)
         if (nextItem == null) nextItem = channel!!.receiveCatching()
-        nextItem?.exceptionOrNull()?.let { throw it }
         return ObjBool(nextItem!!.isSuccess)
     }
 

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

@@ -61,14 +61,6 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
         return if (idx >= 0 && idx < methodSlots.size) methodSlots[idx] else null
     }
 
-    internal fun fieldRecordForId(fieldId: Int): ObjRecord? {
-        return if (fieldId >= 0 && fieldId < fieldSlots.size) fieldSlots[fieldId] else null
-    }
-
-    internal fun methodRecordForId(methodId: Int): ObjRecord? {
-        return if (methodId >= 0 && methodId < methodSlots.size) methodSlots[methodId] else null
-    }
-
     override suspend fun readField(scope: Scope, name: String): ObjRecord {
         val caller = scope.currentClassCtx
         
@@ -174,7 +166,8 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
             }
             del = del ?: scope.raiseError("Internal error: delegated property $name has no delegate")
             val res = del.invokeInstanceMethod(scope, "getValue", Arguments(this, ObjString(name)))
-            return obj.copy(value = res, type = ObjRecord.Type.Other)
+            obj.value = res
+            return obj
         }
 
         // Map member template to instance storage if applicable

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

@@ -29,26 +29,21 @@ import net.sergeych.lyng.miniast.type
  */
 val ObjIterable by lazy {
     ObjClass("Iterable").apply {
-        addFn(
-            name = "iterator",
-            isAbstract = true,
-            isClosed = false,
-            code = null
-        )
 
-        addFnDoc(
+        addPropertyDoc(
             name = "toList",
             doc = "Collect elements of this iterable into a new list.",
-            returns = type("lyng.List"),
+            type = type("lyng.List"),
-            moduleName = "lyng.stdlib"
+            moduleName = "lyng.stdlib",
-        ) {
+            getter = {
                 val result = mutableListOf<Obj>()
-            val it = thisObj.invokeInstanceMethod(this, "iterator")
+                val it = this.thisObj.invokeInstanceMethod(this, "iterator")
                 while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
                     result.add(it.invokeInstanceMethod(this, "next"))
                 }
                 ObjList(result)
             }
+        )
 
         // it is not effective, but it is open:
         addFnDoc(

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

@@ -1,57 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.sergeych.lyng.obj
-
-import net.sergeych.lyng.Arguments
-import net.sergeych.lyng.Scope
-import net.sergeych.lyng.Statement
-
-/**
- * Lazy delegate used by `val x by lazy { ... }`.
- */
-class ObjLazyDelegate(
-    private val builder: Statement,
-    private val capturedScope: Scope,
-) : Obj() {
-    override val objClass: ObjClass = type
-
-    private var calculated = false
-    private var cachedValue: Obj = ObjVoid
-
-    override suspend fun invokeInstanceMethod(
-        scope: Scope,
-        name: String,
-        args: Arguments,
-        onNotFoundResult: (suspend () -> Obj?)?,
-    ): Obj {
-        return when (name) {
-            "getValue" -> {
-                if (!calculated) {
-                    cachedValue = builder.execute(capturedScope)
-                    calculated = true
-                }
-                cachedValue
-            }
-            "setValue" -> scope.raiseIllegalAssignment("lazy delegate is read-only")
-            else -> super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
-        }
-    }
-
-    companion object {
-        val type = ObjClass("LazyDelegate")
-    }
-}

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

@@ -247,10 +247,6 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
 
     companion object {
         val type = object : ObjClass("List", ObjArray) {
-            override suspend fun callOn(scope: Scope): Obj {
-                return ObjList(scope.args.list.toMutableList())
-            }
-
             override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
                 return ObjList(decoder.decodeAnyList(scope))
             }
@@ -523,3 +519,4 @@ fun <T>MutableList<T>.swap(i: Int, j: Int) {
     }
 }
 
+

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

@@ -38,10 +38,6 @@ data class ObjRecord(
     var delegate: Obj? = null,
     /** The receiver object to resolve this member against (for instance fields/methods). */
     var receiver: Obj? = null,
-    val callSignature: net.sergeych.lyng.CallSignature? = null,
-    val memberName: String? = null,
-    val fieldId: Int? = null,
-    val methodId: Int? = null,
 ) {
     val effectiveWriteVisibility: Visibility get() = writeVisibility ?: visibility
     enum class Type(val comparable: Boolean = false,val serializable: Boolean = false) {

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

@@ -18,10 +18,8 @@
 package net.sergeych.lyng.obj
 
 import net.sergeych.lyng.PerfFlags
-import net.sergeych.lyng.Pos
 import net.sergeych.lyng.RegexCache
 import net.sergeych.lyng.Scope
-import net.sergeych.lyng.Statement
 import net.sergeych.lyng.miniast.*
 
 class ObjRegex(val regex: Regex) : Obj() {
@@ -74,19 +72,6 @@ class ObjRegex(val regex: Regex) : Obj() {
                     val s = requireOnlyArg<ObjString>().value
                     ObjList(thisAs<ObjRegex>().regex.findAll(s).map { ObjRegexMatch(it) }.toMutableList())
                 }
-                createField(
-                    name = "operatorMatch",
-                    initialValue = object : Statement() {
-                        override val pos: Pos = Pos.builtIn
-
-                        override suspend fun execute(scope: Scope): Obj {
-                            val other = scope.args.firstAndOnly(pos)
-                            val targetScope = scope.parent ?: scope
-                            return (scope.thisObj as ObjRegex).operatorMatch(targetScope, other)
-                        }
-                    },
-                    type = ObjRecord.Type.Fun
-                )
             }
         }
     }

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

@@ -22,10 +22,8 @@ import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonPrimitive
 import net.sergeych.lyng.PerfFlags
-import net.sergeych.lyng.Pos
 import net.sergeych.lyng.RegexCache
 import net.sergeych.lyng.Scope
-import net.sergeych.lyng.Statement
 import net.sergeych.lyng.miniast.*
 import net.sergeych.lynon.LynonDecoder
 import net.sergeych.lynon.LynonEncoder
@@ -340,36 +338,6 @@ data class ObjString(val value: String) : Obj() {
                     }
                 )
             }
-            createField(
-                name = "re",
-                initialValue = ObjProperty(
-                    name = "re",
-                    getter = object : Statement() {
-                        override val pos: Pos = Pos.builtIn
-
-                        override suspend fun execute(scope: Scope): Obj {
-                            val pattern = (scope.thisObj as ObjString).value
-                            val re = if (PerfFlags.REGEX_CACHE) RegexCache.get(pattern) else pattern.toRegex()
-                            return ObjRegex(re)
-                        }
-                    },
-                    setter = null
-                ),
-                type = ObjRecord.Type.Property
-            )
-            createField(
-                name = "operatorMatch",
-                initialValue = object : Statement() {
-                    override val pos: Pos = Pos.builtIn
-
-                    override suspend fun execute(scope: Scope): Obj {
-                        val other = scope.args.firstAndOnly(pos)
-                        val targetScope = scope.parent ?: scope
-                        return (scope.thisObj as ObjString).operatorMatch(targetScope, other)
-                    }
-                },
-                type = ObjRecord.Type.Fun
-            )
         }
     }
 }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/resolution/CompileTimeResolution.kt

@@ -1,78 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.resolution
-
-import net.sergeych.lyng.Compiler
-import net.sergeych.lyng.Pos
-import net.sergeych.lyng.Source
-import net.sergeych.lyng.pacman.ImportProvider
-
-enum class SymbolOrigin {
-    LOCAL,
-    OUTER,
-    MODULE,
-    MEMBER,
-    PARAM
-}
-
-data class ResolvedSymbol(
-    val name: String,
-    val origin: SymbolOrigin,
-    val slotIndex: Int,
-    val pos: Pos,
-)
-
-data class CaptureInfo(
-    val name: String,
-    val origin: SymbolOrigin,
-    val slotIndex: Int,
-    val isMutable: Boolean,
-    val pos: Pos,
-)
-
-data class ResolutionError(
-    val message: String,
-    val pos: Pos,
-)
-
-data class ResolutionWarning(
-    val message: String,
-    val pos: Pos,
-)
-
-data class ResolutionReport(
-    val moduleName: String,
-    val symbols: List<ResolvedSymbol>,
-    val captures: List<CaptureInfo>,
-    val errors: List<ResolutionError>,
-    val warnings: List<ResolutionWarning>,
-)
-
-object CompileTimeResolver {
-    suspend fun dryRun(source: Source, importProvider: ImportProvider): ResolutionReport {
-        val collector = ResolutionCollector(source.fileName)
-        Compiler.compileWithResolution(
-            source,
-            importProvider,
-            resolutionSink = collector,
-            useBytecodeStatements = false,
-            allowUnresolvedRefs = true
-        )
-        return collector.buildReport()
-    }
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/resolution/ResolutionCollector.kt

@@ -1,376 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.resolution
-
-import net.sergeych.lyng.Pos
-
-class ResolutionCollector(private val moduleName: String) : ResolutionSink {
-
-    private data class Decl(
-        val name: String,
-        val kind: SymbolKind,
-        val isMutable: Boolean,
-        val pos: Pos,
-        val isOverride: Boolean
-    )
-
-    private data class Ref(
-        val name: String,
-        val pos: Pos,
-        val qualifier: String? = null
-    )
-
-    private data class ReflectRef(
-        val name: String,
-        val pos: Pos
-    )
-
-    private data class MemberInfo(
-        val name: String,
-        val isOverride: Boolean,
-        val pos: Pos
-    )
-
-    private data class ClassInfo(
-        val name: String,
-        val bases: List<String>,
-        val pos: Pos,
-        val members: MutableMap<String, MemberInfo> = LinkedHashMap()
-    )
-
-    private class ScopeNode(
-        val kind: ScopeKind,
-        val pos: Pos,
-        val parent: ScopeNode?,
-        val className: String? = null,
-        val bases: List<String> = emptyList()
-    ) {
-        val decls: LinkedHashMap<String, Decl> = LinkedHashMap()
-        val refs: MutableList<Ref> = ArrayList()
-        val memberRefs: MutableList<Ref> = ArrayList()
-        val reflectRefs: MutableList<ReflectRef> = ArrayList()
-        val captures: LinkedHashMap<String, CaptureInfo> = LinkedHashMap()
-        val children: MutableList<ScopeNode> = ArrayList()
-    }
-
-    private var root: ScopeNode? = null
-    private var current: ScopeNode? = null
-
-    private val symbols = ArrayList<ResolvedSymbol>()
-    private val captures = LinkedHashMap<String, CaptureInfo>()
-    private val errors = ArrayList<ResolutionError>()
-    private val warnings = ArrayList<ResolutionWarning>()
-    private val classes = LinkedHashMap<String, ClassInfo>()
-
-    override fun enterScope(kind: ScopeKind, pos: Pos, className: String?, bases: List<String>) {
-        val parent = current
-        val node = ScopeNode(kind, pos, parent, className, bases)
-        if (root == null) {
-            root = node
-        }
-        parent?.children?.add(node)
-        current = node
-        if (kind == ScopeKind.CLASS && className != null) {
-            classes.getOrPut(className) { ClassInfo(className, bases.toList(), pos) }
-        }
-    }
-
-    override fun exitScope(pos: Pos) {
-        current = current?.parent
-    }
-
-    override fun declareClass(name: String, bases: List<String>, pos: Pos) {
-        val existing = classes[name]
-        if (existing == null) {
-            classes[name] = ClassInfo(name, bases.toList(), pos)
-        } else if (existing.bases.isEmpty() && bases.isNotEmpty()) {
-            classes[name] = existing.copy(bases = bases.toList())
-        }
-    }
-
-    override fun declareSymbol(
-        name: String,
-        kind: SymbolKind,
-        isMutable: Boolean,
-        pos: Pos,
-        isOverride: Boolean
-    ) {
-        val node = current ?: return
-        node.decls[name] = Decl(name, kind, isMutable, pos, isOverride)
-        if (kind == SymbolKind.LOCAL || kind == SymbolKind.PARAM) {
-            val classScope = findNearestClassScope(node)
-            if (classScope != null && classScope.decls.containsKey(name)) {
-                warnings += ResolutionWarning("shadowing member: $name", pos)
-            }
-        }
-        if (kind == SymbolKind.MEMBER) {
-            val classScope = findNearestClassScope(node)
-            val className = classScope?.className
-            if (className != null) {
-                val info = classes.getOrPut(className) { ClassInfo(className, classScope.bases, classScope.pos) }
-                info.members[name] = MemberInfo(name, isOverride, pos)
-            }
-        }
-        symbols += ResolvedSymbol(
-            name = name,
-            origin = originForDecl(node, kind),
-            slotIndex = -1,
-            pos = pos
-        )
-    }
-
-    override fun reference(name: String, pos: Pos) {
-        val node = current ?: return
-        node.refs += Ref(name, pos)
-    }
-
-    override fun referenceMember(name: String, pos: Pos, qualifier: String?) {
-        val node = current ?: return
-        node.memberRefs += Ref(name, pos, qualifier)
-    }
-
-    override fun referenceReflection(name: String, pos: Pos) {
-        val node = current ?: return
-        node.reflectRefs += ReflectRef(name, pos)
-    }
-
-    fun buildReport(): ResolutionReport {
-        root?.let { resolveScope(it) }
-        checkMiConflicts()
-        return ResolutionReport(
-            moduleName = moduleName,
-            symbols = symbols.toList(),
-            captures = captures.values.toList(),
-            errors = errors.toList(),
-            warnings = warnings.toList()
-        )
-    }
-
-    private fun resolveScope(node: ScopeNode) {
-        for (ref in node.refs) {
-            if (ref.name == "this") continue
-            if (ref.name == "scope") continue
-            val resolved = resolveName(node, ref)
-            if (!resolved) {
-                errors += ResolutionError("unresolved name: ${ref.name}", ref.pos)
-            }
-        }
-        for (ref in node.memberRefs) {
-            val resolved = resolveMemberName(node, ref)
-            if (!resolved) {
-                errors += ResolutionError("unresolved member: ${ref.name}", ref.pos)
-            }
-        }
-        for (ref in node.reflectRefs) {
-            val resolved = resolveName(node, Ref(ref.name, ref.pos)) ||
-                resolveMemberName(node, Ref(ref.name, ref.pos))
-            if (!resolved) {
-                errors += ResolutionError("unresolved reflected name: ${ref.name}", ref.pos)
-            }
-        }
-        for (child in node.children) {
-            resolveScope(child)
-        }
-    }
-
-    private fun resolveName(node: ScopeNode, ref: Ref): Boolean {
-        if (ref.name.contains('.')) return true
-        var scope: ScopeNode? = node
-        while (scope != null) {
-            val decl = scope.decls[ref.name]
-            if (decl != null) {
-                if (scope !== node) {
-                    recordCapture(node, decl, scope)
-                }
-                return true
-            }
-            scope = scope.parent
-        }
-        return false
-    }
-
-    private fun recordCapture(owner: ScopeNode, decl: Decl, targetScope: ScopeNode) {
-        if (owner.captures.containsKey(decl.name)) return
-        val origin = when (targetScope.kind) {
-            ScopeKind.MODULE -> SymbolOrigin.MODULE
-            else -> SymbolOrigin.OUTER
-        }
-        val capture = CaptureInfo(
-            name = decl.name,
-            origin = origin,
-            slotIndex = -1,
-            isMutable = decl.isMutable,
-            pos = decl.pos
-        )
-        owner.captures[decl.name] = capture
-        captures[decl.name] = capture
-    }
-
-    private fun resolveMemberName(node: ScopeNode, ref: Ref): Boolean {
-        val classScope = findNearestClassScope(node) ?: return false
-        val className = classScope.className ?: return false
-        val qualifier = ref.qualifier
-        return if (qualifier != null) {
-            resolveQualifiedMember(className, qualifier, ref.name, ref.pos)
-        } else {
-            resolveMemberInClass(className, ref.name, ref.pos)
-        }
-    }
-
-    private fun findNearestClassScope(node: ScopeNode): ScopeNode? {
-        var scope: ScopeNode? = node
-        while (scope != null) {
-            if (scope.kind == ScopeKind.CLASS) return scope
-            scope = scope.parent
-        }
-        return null
-    }
-
-    private fun originForDecl(scope: ScopeNode, kind: SymbolKind): SymbolOrigin {
-        return when (kind) {
-            SymbolKind.PARAM -> SymbolOrigin.PARAM
-            SymbolKind.MEMBER -> SymbolOrigin.MEMBER
-            else -> when (scope.kind) {
-                ScopeKind.MODULE -> SymbolOrigin.MODULE
-                ScopeKind.CLASS -> SymbolOrigin.MEMBER
-                else -> SymbolOrigin.LOCAL
-            }
-        }
-    }
-
-    private fun resolveMemberInClass(className: String, member: String, pos: Pos): Boolean {
-        val info = classes[className] ?: return false
-        val currentMember = info.members[member]
-        val definers = findDefiningClasses(className, member)
-        if (currentMember != null) {
-            if (definers.size > 1 && !currentMember.isOverride) {
-                errors += ResolutionError("override required for $member in $className", pos)
-            }
-            return true
-        }
-        if (definers.size > 1) {
-            errors += ResolutionError("ambiguous member '$member' in $className", pos)
-            return true
-        }
-        return definers.isNotEmpty()
-    }
-
-    private fun resolveQualifiedMember(className: String, qualifier: String, member: String, pos: Pos): Boolean {
-        val mro = linearize(className)
-        val idx = mro.indexOf(qualifier)
-        if (idx < 0) return false
-        for (name in mro.drop(idx)) {
-            val info = classes[name]
-            if (info?.members?.containsKey(member) == true) return true
-        }
-        errors += ResolutionError("member '$member' not found in $qualifier", pos)
-        return true
-    }
-
-    private fun findDefiningClasses(className: String, member: String): List<String> {
-        val parents = linearize(className).drop(1)
-        val raw = parents.filter { classes[it]?.members?.containsKey(member) == true }
-        if (raw.size <= 1) return raw
-        val filtered = raw.toMutableList()
-        val iterator = raw.iterator()
-        while (iterator.hasNext()) {
-            val candidate = iterator.next()
-            for (other in raw) {
-                if (candidate == other) continue
-                if (linearize(other).contains(candidate)) {
-                    filtered.remove(candidate)
-                    break
-                }
-            }
-        }
-        return filtered
-    }
-
-    private fun linearize(className: String, visited: MutableMap<String, List<String>> = mutableMapOf()): List<String> {
-        visited[className]?.let { return it }
-        val info = classes[className]
-        val parents = info?.bases ?: emptyList()
-        if (parents.isEmpty()) {
-            val single = listOf(className)
-            visited[className] = single
-            return single
-        }
-        val parentLinearizations = parents.map { linearize(it, visited).toMutableList() }
-        val merge = mutableListOf<MutableList<String>>()
-        merge.addAll(parentLinearizations)
-        merge.add(parents.toMutableList())
-        val merged = c3Merge(merge)
-        val result = listOf(className) + merged
-        visited[className] = result
-        return result
-    }
-
-    private fun c3Merge(seqs: MutableList<MutableList<String>>): List<String> {
-        val result = mutableListOf<String>()
-        while (seqs.isNotEmpty()) {
-            seqs.removeAll { it.isEmpty() }
-            if (seqs.isEmpty()) break
-            var candidate: String? = null
-            outer@ for (seq in seqs) {
-                val head = seq.first()
-                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 ?: run {
-                errors += ResolutionError("C3 MRO failed for $moduleName", Pos.builtIn)
-                return result
-            }
-            result += picked
-            for (seq in seqs) {
-                if (seq.isNotEmpty() && seq.first() == picked) {
-                    seq.removeAt(0)
-                }
-            }
-        }
-        return result
-    }
-
-    private fun checkMiConflicts() {
-        for (info in classes.values) {
-            val baseNames = linearize(info.name).drop(1)
-            if (baseNames.isEmpty()) continue
-            val baseMemberNames = linkedSetOf<String>()
-            for (base in baseNames) {
-                classes[base]?.members?.keys?.let { baseMemberNames.addAll(it) }
-            }
-            for (member in baseMemberNames) {
-                val definers = findDefiningClasses(info.name, member)
-                if (definers.size <= 1) continue
-                val current = info.members[member]
-                if (current == null || !current.isOverride) {
-                    errors += ResolutionError("ambiguous member '$member' in ${info.name}", info.pos)
-                }
-            }
-        }
-    }
-}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/resolution/ResolutionSink.kt

@@ -1,52 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * 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.resolution
-
-import net.sergeych.lyng.Pos
-
-enum class ScopeKind {
-    MODULE,
-    FUNCTION,
-    BLOCK,
-    CLASS
-}
-
-enum class SymbolKind {
-    LOCAL,
-    PARAM,
-    FUNCTION,
-    CLASS,
-    ENUM,
-    MEMBER
-}
-
-interface ResolutionSink {
-    fun enterScope(kind: ScopeKind, pos: Pos, className: String? = null, bases: List<String> = emptyList()) {}
-    fun exitScope(pos: Pos) {}
-    fun declareClass(name: String, bases: List<String>, pos: Pos) {}
-    fun declareSymbol(
-        name: String,
-        kind: SymbolKind,
-        isMutable: Boolean,
-        pos: Pos,
-        isOverride: Boolean = false
-    ) {}
-    fun reference(name: String, pos: Pos) {}
-    fun referenceMember(name: String, pos: Pos, qualifier: String? = null) {}
-    fun referenceReflection(name: String, pos: Pos) {}
-}

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

@@ -19,17 +19,7 @@ package net.sergeych.lyng
 
 import net.sergeych.lyng.obj.Obj
 import net.sergeych.lyng.obj.ObjClass
-import net.sergeych.lyng.obj.ObjInt
-import net.sergeych.lyng.obj.ObjIterable
-import net.sergeych.lyng.obj.ObjNull
-import net.sergeych.lyng.obj.ObjException
-import net.sergeych.lyng.obj.ObjRange
-import net.sergeych.lyng.obj.ObjRecord
-import net.sergeych.lyng.obj.ObjString
 import net.sergeych.lyng.obj.ObjVoid
-import net.sergeych.lyng.obj.toBool
-import net.sergeych.lyng.obj.toInt
-import net.sergeych.lyng.obj.toLong
 
 fun String.toSource(name: String = "eval"): Source = Source(name, this)
 
@@ -73,381 +63,6 @@ abstract class Statement(
 
 }
 
-class IfStatement(
-    val condition: Statement,
-    val ifBody: Statement,
-    val elseBody: Statement?,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        return if (condition.execute(scope).toBool()) {
-            ifBody.execute(scope)
-        } else {
-            elseBody?.execute(scope) ?: ObjVoid
-        }
-    }
-}
-
-data class ConstIntRange(val start: Long, val endExclusive: Long)
-
-class ForInStatement(
-    val loopVarName: String,
-    val source: Statement,
-    val constRange: ConstIntRange?,
-    val body: Statement,
-    val elseStatement: Statement?,
-    val label: String?,
-    val canBreak: Boolean,
-    val loopSlotPlan: Map<String, Int>,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        val forContext = scope.createChildScope(pos)
-        if (loopSlotPlan.isNotEmpty()) {
-            forContext.applySlotPlan(loopSlotPlan)
-        }
-
-        val loopSO = forContext.addItem(loopVarName, true, ObjNull)
-        val loopSlotIndex = forContext.getSlotIndexOf(loopVarName) ?: -1
-
-        if (constRange != null && PerfFlags.PRIMITIVE_FASTOPS) {
-            return loopIntRange(
-                forContext,
-                constRange.start,
-                constRange.endExclusive,
-                loopSO,
-                loopSlotIndex,
-                body,
-                elseStatement,
-                label,
-                canBreak
-            )
-        }
-
-        val sourceObj = source.execute(forContext)
-        return if (sourceObj is ObjRange && sourceObj.isIntRange && PerfFlags.PRIMITIVE_FASTOPS) {
-            loopIntRange(
-                forContext,
-                sourceObj.start!!.toLong(),
-                if (sourceObj.isEndInclusive) sourceObj.end!!.toLong() + 1 else sourceObj.end!!.toLong(),
-                loopSO,
-                loopSlotIndex,
-                body,
-                elseStatement,
-                label,
-                canBreak
-            )
-        } else if (sourceObj.isInstanceOf(ObjIterable)) {
-            loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak)
-        } else {
-            val size = runCatching { sourceObj.readField(forContext, "size").value.toInt() }
-                .getOrElse {
-                    throw ScriptError(
-                        pos,
-                        "object is not enumerable: no size in $sourceObj",
-                        it
-                    )
-                }
-
-            var result: Obj = ObjVoid
-            var breakCaught = false
-
-            if (size > 0) {
-                var current = runCatching { sourceObj.getAt(forContext, ObjInt.of(0)) }
-                    .getOrElse {
-                        throw ScriptError(
-                            pos,
-                            "object is not enumerable: no index access for ${sourceObj.inspect(scope)}",
-                            it
-                        )
-                    }
-                var index = 0
-                while (true) {
-                    loopSO.value = current
-                    try {
-                        result = body.execute(forContext)
-                    } catch (lbe: LoopBreakContinueException) {
-                        if (lbe.label == label || lbe.label == null) {
-                            breakCaught = true
-                            if (lbe.doContinue) continue
-                            result = lbe.result
-                            break
-                        } else {
-                            throw lbe
-                        }
-                    }
-                    if (++index >= size) break
-                    current = sourceObj.getAt(forContext, ObjInt.of(index.toLong()))
-                }
-            }
-            if (!breakCaught && elseStatement != null) {
-                result = elseStatement.execute(scope)
-            }
-            result
-        }
-    }
-
-    private suspend fun loopIntRange(
-        forScope: Scope,
-        start: Long,
-        end: Long,
-        loopVar: ObjRecord,
-        loopSlotIndex: Int,
-        body: Statement,
-        elseStatement: Statement?,
-        label: String?,
-        catchBreak: Boolean,
-    ): Obj {
-        var result: Obj = ObjVoid
-        val cacheLow = ObjInt.CACHE_LOW
-        val cacheHigh = ObjInt.CACHE_HIGH
-        val useCache = start >= cacheLow && end <= cacheHigh + 1
-        val cache = if (useCache) ObjInt.cacheArray() else null
-        val useSlot = loopSlotIndex >= 0
-        if (catchBreak) {
-            if (useCache && cache != null) {
-                var i = start
-                while (i < end) {
-                    val v = cache[(i - cacheLow).toInt()]
-                    if (useSlot) forScope.setSlotValue(loopSlotIndex, v) else loopVar.value = v
-                    try {
-                        result = body.execute(forScope)
-                    } catch (lbe: LoopBreakContinueException) {
-                        if (lbe.label == label || lbe.label == null) {
-                            if (lbe.doContinue) {
-                                i++
-                                continue
-                            }
-                            return lbe.result
-                        }
-                        throw lbe
-                    }
-                    i++
-                }
-            } else {
-                for (i in start..<end) {
-                    val v = ObjInt.of(i)
-                    if (useSlot) forScope.setSlotValue(loopSlotIndex, v) else loopVar.value = v
-                    try {
-                        result = body.execute(forScope)
-                    } catch (lbe: LoopBreakContinueException) {
-                        if (lbe.label == label || lbe.label == null) {
-                            if (lbe.doContinue) continue
-                            return lbe.result
-                        }
-                        throw lbe
-                    }
-                }
-            }
-        } else {
-            if (useCache && cache != null) {
-                var i = start
-                while (i < end) {
-                    val v = cache[(i - cacheLow).toInt()]
-                    if (useSlot) forScope.setSlotValue(loopSlotIndex, v) else loopVar.value = v
-                    result = body.execute(forScope)
-                    i++
-                }
-            } else {
-                for (i in start..<end) {
-                    val v = ObjInt.of(i)
-                    if (useSlot) forScope.setSlotValue(loopSlotIndex, v) else loopVar.value = v
-                    result = body.execute(forScope)
-                }
-            }
-        }
-        return elseStatement?.execute(forScope) ?: result
-    }
-
-    private suspend fun loopIterable(
-        forScope: Scope,
-        sourceObj: Obj,
-        loopVar: ObjRecord,
-        body: Statement,
-        elseStatement: Statement?,
-        label: String?,
-        catchBreak: Boolean,
-    ): Obj {
-        var result: Obj = ObjVoid
-        var breakCaught = false
-        sourceObj.enumerate(forScope) { item ->
-            loopVar.value = item
-            if (catchBreak) {
-                try {
-                    result = body.execute(forScope)
-                    true
-                } catch (lbe: LoopBreakContinueException) {
-                    if (lbe.label == label || lbe.label == null) {
-                        breakCaught = true
-                        if (lbe.doContinue) true else {
-                            result = lbe.result
-                            false
-                        }
-                    } else {
-                        throw lbe
-                    }
-                }
-            } else {
-                result = body.execute(forScope)
-                true
-            }
-        }
-        if (!breakCaught && elseStatement != null) {
-            result = elseStatement.execute(forScope)
-        }
-        return result
-    }
-}
-
-class WhileStatement(
-    val condition: Statement,
-    val body: Statement,
-    val elseStatement: Statement?,
-    val label: String?,
-    val canBreak: Boolean,
-    val loopSlotPlan: Map<String, Int>,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        var result: Obj = ObjVoid
-        var wasBroken = false
-        while (condition.execute(scope).toBool()) {
-            val loopScope = scope.createChildScope().apply { skipScopeCreation = true }
-            if (canBreak) {
-                try {
-                    result = body.execute(loopScope)
-                } catch (lbe: LoopBreakContinueException) {
-                    if (lbe.label == label || lbe.label == null) {
-                        if (lbe.doContinue) continue
-                        result = lbe.result
-                        wasBroken = true
-                        break
-                    } else {
-                        throw lbe
-                    }
-                }
-            } else {
-                result = body.execute(loopScope)
-            }
-        }
-        if (!wasBroken) elseStatement?.let { s -> result = s.execute(scope) }
-        return result
-    }
-}
-
-class DoWhileStatement(
-    val body: Statement,
-    val condition: Statement,
-    val elseStatement: Statement?,
-    val label: String?,
-    val loopSlotPlan: Map<String, Int>,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        var wasBroken = false
-        var result: Obj = ObjVoid
-        while (true) {
-            val doScope = scope.createChildScope().apply { skipScopeCreation = true }
-            try {
-                result = body.execute(doScope)
-            } catch (e: LoopBreakContinueException) {
-                if (e.label == label || e.label == null) {
-                    if (!e.doContinue) {
-                        result = e.result
-                        wasBroken = true
-                        break
-                    }
-                    // continue: fall through to condition check
-                } else {
-                    throw e
-                }
-            }
-            if (!condition.execute(doScope).toBool()) {
-                break
-            }
-        }
-        if (!wasBroken) elseStatement?.let { s -> result = s.execute(scope) }
-        return result
-    }
-}
-
-class BreakStatement(
-    val label: String?,
-    val resultExpr: Statement?,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        val returnValue = resultExpr?.execute(scope)
-        throw LoopBreakContinueException(
-            doContinue = false,
-            label = label,
-            result = returnValue ?: ObjVoid
-        )
-    }
-}
-
-class ContinueStatement(
-    val label: String?,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        throw LoopBreakContinueException(
-            doContinue = true,
-            label = label,
-        )
-    }
-}
-
-class ReturnStatement(
-    val label: String?,
-    val resultExpr: Statement?,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        val returnValue = resultExpr?.execute(scope) ?: ObjVoid
-        throw ReturnException(returnValue, label)
-    }
-}
-
-class ThrowStatement(
-    val throwExpr: Statement,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        var errorObject = throwExpr.execute(scope)
-        val throwScope = scope.createChildScope(pos = pos)
-        if (errorObject is ObjString) {
-            errorObject = ObjException(throwScope, errorObject.value).apply { getStackTrace() }
-        }
-        if (!errorObject.isInstanceOf(ObjException.Root)) {
-            throwScope.raiseError("this is not an exception object: $errorObject")
-        }
-        if (errorObject is ObjException) {
-            errorObject = ObjException(
-                errorObject.exceptionClass,
-                throwScope,
-                errorObject.message,
-                errorObject.extraData,
-                errorObject.useStackTrace
-            ).apply { getStackTrace() }
-            throwScope.raiseError(errorObject)
-        } else {
-            val msg = errorObject.invokeInstanceMethod(scope, "message").toString(scope).value
-            throwScope.raiseError(errorObject, pos, msg)
-        }
-        return ObjVoid
-    }
-}
-
-class ToBoolStatement(
-    val expr: Statement,
-    override val pos: Pos,
-) : Statement() {
-    override suspend fun execute(scope: Scope): Obj {
-        return if (expr.execute(scope).toBool()) net.sergeych.lyng.obj.ObjTrue else net.sergeych.lyng.obj.ObjFalse
-    }
-}
-
 class ExpressionStatement(
     val ref: net.sergeych.lyng.obj.ObjRef,
     override val pos: Pos

lynglib/src/commonTest/kotlin/BindingHighlightTest.kt

@@ -21,13 +21,11 @@ import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.binding.Binder
 import net.sergeych.lyng.binding.SymbolKind
 import net.sergeych.lyng.miniast.MiniAstBuilder
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
-@Ignore
 class BindingHighlightTest {
 
     private suspend fun compileWithMini(code: String): Pair<Script, MiniAstBuilder> {

lynglib/src/commonTest/kotlin/BindingTest.kt

@@ -23,13 +23,11 @@ package net.sergeych.lyng
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.binding.Binder
 import net.sergeych.lyng.miniast.MiniAstBuilder
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
-@Ignore
 class BindingTest {
 
     private suspend fun bind(code: String): net.sergeych.lyng.binding.BindingSnapshot {

lynglib/src/commonTest/kotlin/BytecodeRecentOpsTest.kt

@@ -1,76 +0,0 @@
-import kotlinx.coroutines.test.runTest
-import net.sergeych.lyng.eval
-import kotlin.test.Test
-import kotlin.test.Ignore
-
-@Ignore
-class BytecodeRecentOpsTest {
-
-    @Test
-    fun listLiteralWithSpread() = runTest {
-        eval(
-            """
-            val a = [1, 2, 3]
-            val b = [0, ...a, 4]
-            assertEquals(5, b.size)
-            assertEquals(0, b[0])
-            assertEquals(1, b[1])
-            assertEquals(4, b[4])
-            """.trimIndent()
-        )
-    }
-
-    @Test
-    fun valueFnRefViaClassOperator() = runTest {
-        eval(
-            """
-            val c = 1::class
-            assertEquals("Int", c.className)
-            """.trimIndent()
-        )
-    }
-
-    @Test
-    fun implicitThisCompoundAssign() = runTest {
-        eval(
-            """
-            class C {
-                var x = 1
-                fun add(n) { x += n }
-                fun calc() { add(2); x }
-            }
-            val c = C()
-            assertEquals(3, c.calc())
-            """.trimIndent()
-        )
-    }
-
-    @Test
-    fun optionalCompoundAssignEvaluatesRhsOnce() = runTest {
-        eval(
-            """
-            var count = 0
-            fun inc() { count = count + 1; return 3 }
-            class Box(var v)
-            var b = Box(1)
-            b?.v += inc()
-            assertEquals(4, b.v)
-            assertEquals(1, count)
-            """.trimIndent()
-        )
-    }
-
-    @Test
-    fun optionalIndexCompoundAssignEvaluatesRhsOnce() = runTest {
-        eval(
-            """
-            var count = 0
-            fun inc() { count = count + 1; return 2 }
-            var a = [1, 2, 3]
-            a?[1] += inc()
-            assertEquals(4, a[1])
-            assertEquals(1, count)
-            """.trimIndent()
-        )
-    }
-}

lynglib/src/commonTest/kotlin/CompileTimeResolutionDryRunTest.kt

@@ -1,174 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-import kotlinx.coroutines.test.runTest
-import net.sergeych.lyng.Compiler
-import net.sergeych.lyng.Script
-import net.sergeych.lyng.Source
-import net.sergeych.lyng.resolution.CompileTimeResolver
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-
-class CompileTimeResolutionDryRunTest {
-
-    @Test
-    fun dryRunReturnsMetadataContainer() = runTest {
-        val report = CompileTimeResolver.dryRun(
-            Source("<dry-run>", "val x = 1"),
-            Script.defaultImportManager
-        )
-        assertEquals("<dry-run>", report.moduleName)
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun compilerDryRunEntryPoint() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "val x = 1"),
-            Script.defaultImportManager
-        )
-        assertEquals("<dry-run>", report.moduleName)
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun dryRunCollectsModuleSymbols() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "val x = 1\nfun f() { x }\nclass C"),
-            Script.defaultImportManager
-        )
-        val names = report.symbols.map { it.name }.toSet()
-        assertTrue("x" in names)
-        assertTrue("f" in names)
-        assertTrue("C" in names)
-    }
-
-    @Test
-    fun dryRunCollectsObjectSymbols() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "object O { val x = 1 }\nO"),
-            Script.defaultImportManager
-        )
-        val names = report.symbols.map { it.name }.toSet()
-        assertTrue("O" in names)
-    }
-
-    @Test
-    fun dryRunCollectsCtorParams() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "class C(x) { val y = x }"),
-            Script.defaultImportManager
-        )
-        val names = report.symbols.map { it.name }.toSet()
-        assertTrue("x" in names)
-    }
-
-    @Test
-    fun dryRunCollectsMapLiteralShorthandRefs() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "val x = 1\nval m = { x: }\nm"),
-            Script.defaultImportManager
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun dryRunCollectsBaseClassRefs() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "class A {}\nclass B : A {}"),
-            Script.defaultImportManager
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun dryRunCollectsTypeRefs() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "class A {}\nval x: A = A()"),
-            Script.defaultImportManager
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun dryRunAcceptsQualifiedTypeRefs() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "val x: lyng.time.Instant? = null"),
-            Script.defaultImportManager
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun dryRunCollectsExtensionReceiverRefs() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "class A {}\nfun A.foo() = 1\nval A.bar get() = 2"),
-            Script.defaultImportManager
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun dryRunAcceptsLoopAndCatchLocals() = runTest {
-        val report = Compiler.dryRun(
-            Source(
-                "<dry-run>",
-                """
-                fun f() {
-                    for (i in 0..2) { i }
-                    try { 1 } catch(e: Exception) { e }
-                }
-                """.trimIndent()
-            ),
-            Script.defaultImportManager
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun dryRunCollectsCaptures() = runTest {
-        val report = Compiler.dryRun(
-            Source("<dry-run>", "val x = 1\nval f = { x }\nf()"),
-            Script.defaultImportManager
-        )
-        val captureNames = report.captures.map { it.name }.toSet()
-        assertTrue("x" in captureNames)
-    }
-
-    @Test
-    fun dryRunAcceptsScopeReflectionHelpers() = runTest {
-        val report = Compiler.dryRun(
-            Source(
-                "<dry-run>",
-                """
-                fun f() {
-                    var x = 1
-                    scope.get("x")
-                    scope.set("x", 2)
-                    scope.locals()
-                    scope.captures()
-                    scope.members()
-                }
-                f()
-                """.trimIndent()
-            ),
-            Script.defaultImportManager
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-}

lynglib/src/commonTest/kotlin/CompileTimeResolutionRuntimeTest.kt

@@ -1,94 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-import kotlinx.coroutines.test.runTest
-import net.sergeych.lyng.Compiler
-import net.sergeych.lyng.Script
-import net.sergeych.lyng.Source
-import net.sergeych.lyng.obj.toInt
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class CompileTimeResolutionRuntimeTest {
-
-    @Test
-    fun strictSlotRefsAllowCapturedLocals() = runTest {
-        val code = """
-            fun outer() {
-                var x = 1
-                fun inner() { x = 3; x }
-                inner()
-            }
-            outer()
-        """.trimIndent()
-        val script = Compiler.compileWithResolution(
-            Source("<strict-slot>", code),
-            Script.defaultImportManager,
-            useBytecodeStatements = false,
-            strictSlotRefs = true
-        )
-        val result = script.execute(Script.defaultImportManager.newStdScope())
-        assertEquals(3, result.toInt())
-    }
-
-    @Test
-    fun bytecodeRespectsShadowingInNestedBlock() = runTest {
-        val code = """
-            fun outer() {
-                var x = 1
-                val y = {
-                    var x = 10
-                    x + 1
-                }
-                y() + x
-            }
-            outer()
-        """.trimIndent()
-        val script = Compiler.compileWithResolution(
-            Source("<shadow-slot>", code),
-            Script.defaultImportManager,
-            useBytecodeStatements = true,
-            strictSlotRefs = true
-        )
-        val result = script.execute(Script.defaultImportManager.newStdScope())
-        assertEquals(12, result.toInt())
-    }
-
-    @Test
-    fun bytecodeRespectsShadowingInBlockStatement() = runTest {
-        val code = """
-            fun outer() {
-                var x = 1
-                var y = 0
-                if (true) {
-                    var x = 10
-                    y = x + 1
-                }
-                y + x
-            }
-            outer()
-        """.trimIndent()
-        val script = Compiler.compileWithResolution(
-            Source("<shadow-block>", code),
-            Script.defaultImportManager,
-            useBytecodeStatements = true,
-            strictSlotRefs = true
-        )
-        val result = script.execute(Script.defaultImportManager.newStdScope())
-        assertEquals(12, result.toInt(), "result=${result.toInt()}")
-    }
-}

lynglib/src/commonTest/kotlin/CompileTimeResolutionSpecTest.kt

@@ -1,192 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-import kotlinx.coroutines.test.runTest
-import net.sergeych.lyng.Compiler
-import net.sergeych.lyng.Script
-import net.sergeych.lyng.Source
-import net.sergeych.lyng.resolution.SymbolOrigin
-import kotlin.test.Ignore
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-
-class CompileTimeResolutionSpecTest {
-
-    private suspend fun dryRun(code: String) =
-        Compiler.dryRun(Source("<dry-run>", code.trimIndent()), Script.defaultImportManager)
-
-    @Test
-    fun resolvesLocalsBeforeMembers() = runTest {
-        val report = dryRun(
-            """
-            class C {
-                val x = 1
-                fun f() { val x = 2; x }
-            }
-            """
-        )
-        assertTrue(report.errors.isEmpty())
-        assertTrue(report.warnings.any { it.message.contains("shadowing member: x") })
-    }
-
-    @Test
-    fun capturesOuterLocalsDeterministically() = runTest {
-        val report = dryRun(
-            """
-            var g = 1
-            fun f() {
-                var g = 2
-                val h = { g }
-                h()
-            }
-            """
-        )
-        assertTrue(report.errors.isEmpty())
-        assertTrue(report.captures.any { it.name == "g" && it.origin == SymbolOrigin.OUTER })
-    }
-
-    @Test
-    fun capturesModuleGlobalsAsOuterScope() = runTest {
-        val report = dryRun(
-            """
-            val G = 10
-            fun f(x=0) = x + G
-            """
-        )
-        assertTrue(report.errors.isEmpty())
-        assertTrue(report.captures.any { it.name == "G" && it.origin == SymbolOrigin.MODULE })
-    }
-
-    @Test
-    fun unresolvedNameIsCompileError() = runTest {
-        val report = dryRun(
-            """
-            fun f() { missingName }
-            f()
-            """
-        )
-        assertTrue(report.errors.any { it.message.contains("missingName") })
-    }
-
-    @Test
-    fun miAmbiguityIsCompileError() = runTest {
-        val report = dryRun(
-            """
-            class A { fun foo() = 1 }
-            class B { fun foo() = 2 }
-            class C : A, B { }
-            C().foo()
-            """
-        )
-        assertTrue(report.errors.isNotEmpty())
-    }
-
-    @Test
-    fun miOverrideResolvesConflict() = runTest {
-        val report = dryRun(
-            """
-            class A { fun foo() = 1 }
-            class B { fun foo() = 2 }
-            class C : A, B {
-                override fun foo() = 3
-            }
-            C().foo()
-            """
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun qualifiedThisMemberAccess() = runTest {
-        val report = dryRun(
-            """
-            class A { fun foo() = 1 }
-            class B { fun foo() = 2 }
-            class C : A, B {
-                override fun foo() = 3
-                fun aFoo() = this@A.foo()
-                fun bFoo() = this@B.foo()
-            }
-            val c = C()
-            c.aFoo()
-            c.bFoo()
-            """
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun reflectionIsExplicitOnly() = runTest {
-        val report = dryRun(
-            """
-            fun f() {
-                val x = 1
-                scope.get("x")
-            }
-            f()
-            """
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun memberShadowingAllowedWithWarning() = runTest {
-        val report = dryRun(
-            """
-            class C {
-                val x = 1
-                fun f() { val x = 2; x }
-            }
-            """
-        )
-        assertTrue(report.errors.isEmpty())
-        assertTrue(report.warnings.any { it.message.contains("shadowing member: x") })
-    }
-
-    @Test
-    fun parameterShadowingAllowed() = runTest {
-        val report = dryRun(
-            """
-            fun f(a=0) {
-                var a = a * 10
-                a
-            }
-            """
-        )
-        assertTrue(report.errors.isEmpty())
-    }
-
-    @Test
-    fun shadowingCaptureIsAllowed() = runTest {
-        val report = dryRun(
-            """
-            fun outer() {
-                var x = 1
-                fun inner() {
-                    val x = 2
-                    val c = { x }
-                    c()
-                }
-                inner()
-            }
-            """
-        )
-        assertTrue(report.errors.isEmpty())
-        assertTrue(report.captures.any { it.name == "x" && it.origin == SymbolOrigin.OUTER })
-    }
-}

lynglib/src/commonTest/kotlin/CoroutinesTest.kt

@@ -17,10 +17,8 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 
-@Ignore
 class TestCoroutines {
 
     @Test

lynglib/src/commonTest/kotlin/EmbeddingExceptionTest.kt

@@ -21,13 +21,11 @@ import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.obj.*
 import net.sergeych.lynon.lynonDecodeAny
 import net.sergeych.lynon.lynonEncodeAny
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertIs
 import kotlin.test.assertTrue
 
-@Ignore
 class EmbeddingExceptionTest {
 
     @Test

lynglib/src/commonTest/kotlin/IfNullAssignTest.kt

@@ -2,9 +2,7 @@
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
 import kotlin.test.Test
-import kotlin.test.Ignore
 
-@Ignore
 class IfNullAssignTest {
 
     @Test

lynglib/src/commonTest/kotlin/MIC3MroTest.kt

@@ -21,10 +21,8 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 
-@Ignore
 class MIC3MroTest {
 
     @Test

lynglib/src/commonTest/kotlin/MIDiagnosticsTest.kt

@@ -21,12 +21,10 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertFails
 import kotlin.test.assertTrue
 
-@Ignore
 class MIDiagnosticsTest {
 
     @Test
@@ -87,7 +85,6 @@ class MIDiagnosticsTest {
     }
 
     @Test
-    @Ignore
     fun castFailureMentionsActualAndTargetTypes() = runTest {
         val ex = assertFails {
             eval(

lynglib/src/commonTest/kotlin/MIQualifiedDispatchTest.kt

@@ -17,10 +17,8 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 
-@Ignore
 class MIQualifiedDispatchTest {
 
     @Test

lynglib/src/commonTest/kotlin/MIVisibilityTest.kt

@@ -19,9 +19,7 @@ import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
 import kotlin.test.Test
 import kotlin.test.assertFails
-import kotlin.test.Ignore
 
-@Ignore
 class MIVisibilityTest {
 
     @Test

lynglib/src/commonTest/kotlin/MapLiteralTest.kt

@@ -23,12 +23,10 @@ import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.ExecutionError
 import net.sergeych.lyng.ScriptError
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
-@Ignore
 class MapLiteralTest {
 
     @Test

lynglib/src/commonTest/kotlin/MiniAstTest.kt

@@ -23,13 +23,11 @@ package net.sergeych.lyng
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.highlight.offsetOf
 import net.sergeych.lyng.miniast.*
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
-@Ignore
 class MiniAstTest {
 
     private suspend fun compileWithMini(code: String): Pair<Script, net.sergeych.lyng.miniast.MiniAstBuilder> {

lynglib/src/commonTest/kotlin/NamedArgsTest.kt

@@ -22,11 +22,9 @@
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.ExecutionError
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertFailsWith
 
-@Ignore
 class NamedArgsTest {
 
     @Test

lynglib/src/commonTest/kotlin/NestedRangeBenchmarkTest.kt

@@ -17,24 +17,18 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.Benchmarks
-import net.sergeych.lyng.Compiler
+import net.sergeych.lyng.eval
-import net.sergeych.lyng.ForInStatement
-import net.sergeych.lyng.Script
-import net.sergeych.lyng.Statement
-import net.sergeych.lyng.bytecode.CmdDisassembler
-import net.sergeych.lyng.bytecode.BytecodeStatement
 import net.sergeych.lyng.obj.ObjInt
 import kotlin.time.TimeSource
 import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.Ignore
 
-@Ignore
 class NestedRangeBenchmarkTest {
     @Test
     fun benchmarkHappyNumbersNestedRanges() = runTest {
         if (!Benchmarks.enabled) return@runTest
-        val bodyScript = """
+        val script = """
+            fun naiveCountHappyNumbers() {
                 var count = 0
                 for( n1 in 0..9 )
                     for( n2 in 0..9 )
@@ -44,58 +38,14 @@ class NestedRangeBenchmarkTest {
                                     for( n6 in 0..9 )
                                         if( n1 + n2 + n3 == n4 + n5 + n6 ) count++
                 count
+            }
+            naiveCountHappyNumbers()
         """.trimIndent()
 
-        val compiled = Compiler.compile(bodyScript)
-        dumpNestedLoopBytecode(compiled.debugStatements())
-
-        val script = """
-            fun naiveCountHappyNumbers() {
-                $bodyScript
-            }
-        """.trimIndent()
-
-        val scope = Script.newScope()
-        scope.eval(script)
-        val fnDisasm = scope.disassembleSymbol("naiveCountHappyNumbers")
-        println("[DEBUG_LOG] [BENCH] nested-happy function naiveCountHappyNumbers cmd:\n$fnDisasm")
-        runMode(scope)
-    }
-
-    private suspend fun runMode(scope: net.sergeych.lyng.Scope) {
         val start = TimeSource.Monotonic.markNow()
-        val result = scope.eval("naiveCountHappyNumbers()") as ObjInt
+        val result = eval(script) as ObjInt
         val elapsedMs = start.elapsedNow().inWholeMilliseconds
         println("[DEBUG_LOG] [BENCH] nested-happy elapsed=${elapsedMs} ms")
         assertEquals(55252L, result.value)
     }
-
-    private fun dumpNestedLoopBytecode(statements: List<Statement>) {
-        var current: Statement? = statements.firstOrNull { stmt ->
-            stmt is BytecodeStatement && stmt.original is ForInStatement
-        }
-        var depth = 1
-        while (current is BytecodeStatement && current.original is ForInStatement) {
-            val original = current.original as ForInStatement
-            println(
-                "[DEBUG_LOG] [BENCH] nested-happy loop depth=$depth " +
-                    "constRange=${original.constRange} canBreak=${original.canBreak} " +
-                    "loopSlotPlan=${original.loopSlotPlan}"
-            )
-            val fn = current.bytecodeFunction()
-            val slots = fn.scopeSlotNames.mapIndexed { idx, name ->
-                val slotName = name ?: "s$idx"
-                "$slotName@${fn.scopeSlotIndices[idx]}"
-            }
-            println("[DEBUG_LOG] [BENCH] nested-happy slots depth=$depth: ${slots.joinToString(", ")}")
-            val disasm = CmdDisassembler.disassemble(fn)
-            println("[DEBUG_LOG] [BENCH] nested-happy cmd depth=$depth:\n$disasm")
-            current = original.body
-            depth += 1
-        }
-        if (depth == 1) {
-            println("[DEBUG_LOG] [BENCH] nested-happy cmd: <not found>")
-        }
-    }
-
 }

lynglib/src/commonTest/kotlin/OOTest.kt

@@ -22,12 +22,10 @@ import net.sergeych.lyng.eval
 import net.sergeych.lyng.obj.ObjInstance
 import net.sergeych.lyng.obj.ObjList
 import net.sergeych.lyng.toSource
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFails
 
-@Ignore
 class OOTest {
     @Test
     fun testClassProps() = runTest {

lynglib/src/commonTest/kotlin/ObjectExpressionTest.kt

@@ -2,11 +2,9 @@ package net.sergeych.lyng
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lynon.lynonEncodeAny
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertFailsWith
 
-@Ignore
 class ObjectExpressionTest {
 
     @Test

lynglib/src/commonTest/kotlin/ParallelLocalScopeTest.kt

@@ -31,12 +31,11 @@ class ParallelLocalScopeTest {
         eval(
             """
             class AtomicCounter {
-                private val m: Mutex = Mutex()
+                private val m = Mutex()
                 private var counter = 0
 
                 fun increment() {
-                    val mm: Mutex = m
+                    m.withLock {
-                    mm.withLock {
                         val a = counter
                         delay(1)
                         counter = a + 1

lynglib/src/commonTest/kotlin/ReturnStatementTest.kt

@@ -2,12 +2,10 @@ import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.ScriptError
 import net.sergeych.lyng.eval
 import net.sergeych.lyng.obj.toInt
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
-@Ignore
 class ReturnStatementTest {
 
     @Test

lynglib/src/commonTest/kotlin/ScopeCycleRegressionTest.kt

@@ -4,7 +4,6 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 
 class ScopeCycleRegressionTest {
@@ -19,10 +18,10 @@ class ScopeCycleRegressionTest {
                     }
                 }
 
-                fun ll(): Whatever { Whatever() }
+                fun ll() { Whatever() }
 
                 fun callTest1() {
-                    val l: Whatever = ll()
+                    val l = ll()
                     l.something()
                     "ok"
                 }

lynglib/src/commonTest/kotlin/ScriptTest_OptionalAssign.kt

@@ -21,7 +21,6 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 
 class ScriptTest_OptionalAssign {
@@ -31,7 +30,7 @@ class ScriptTest_OptionalAssign {
         eval(
             """
             class C { var x = 1 }
-            var c: C? = null
+            var c = null
             // should be no-op and not throw
             c?.x = 5
             assertEquals(null, c?.x)
@@ -47,7 +46,7 @@ class ScriptTest_OptionalAssign {
     fun optionalIndexAssignIsNoOp() = runTest {
         eval(
             """
-            var a: List<Int>? = null
+            var a = null
             // should be no-op and not throw
             a?[0] = 42
             assertEquals(null, a?[0])

lynglib/src/commonTest/kotlin/StdlibWasmSmokeTest.kt

@@ -1,33 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-import kotlinx.coroutines.test.runTest
-import net.sergeych.lyng.eval
-import kotlin.test.Test
-
-class StdlibWasmSmokeTest {
-    @Test
-    fun stdlibIterableExtensionsSmoke() = runTest {
-        eval(
-            """
-            assertEquals(6, [1,2,3].sum())
-            assertEquals([2,4,6], [1,2,3].map { it * 2 })
-            assertEquals([1,2,2,3,3,4], [1,2,3].flatMap { [it, it+1] })
-            """.trimIndent()
-        )
-    }
-}

lynglib/src/commonTest/kotlin/TestInheritance.kt

@@ -17,7 +17,6 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 
 /*
@@ -37,7 +36,6 @@ import kotlin.test.Test
  *
  */
 
-@Ignore
 class TestInheritance {
 
     @Test

lynglib/src/commonTest/kotlin/TypesTest.kt

@@ -17,10 +17,8 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 
-@Ignore
 class TypesTest {
 
     @Test

lynglib/src/commonTest/kotlin/ValReassignRegressionTest.kt

@@ -17,10 +17,8 @@
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.eval
-import kotlin.test.Ignore
 import kotlin.test.Test
 
-@Ignore
 class ValReassignRegressionTest {
 
     @Test

lynglib/src/commonTest/kotlin/net/sergeych/lyng/DelegationTest.kt

@@ -18,10 +18,8 @@
 package net.sergeych.lyng
 
 import kotlinx.coroutines.test.runTest
-import kotlin.test.Ignore
 import kotlin.test.Test
 
-@Ignore
 class DelegationTest {
 
     @Test

lynglib/src/commonTest/kotlin/net/sergeych/lyng/OperatorOverloadingTest.kt

@@ -1,10 +1,8 @@
 package net.sergeych.lyng
 
 import kotlinx.coroutines.test.runTest
-import kotlin.test.Ignore
 import kotlin.test.Test
 
-@Ignore
 class OperatorOverloadingTest {
     @Test
     fun testBinaryOverloading() = runTest {

lynglib/src/commonTest/kotlin/net/sergeych/lyng/PropsTest.kt

@@ -1,7 +1,6 @@
 package net.sergeych.lyng
 
 import kotlinx.coroutines.test.runTest
-import kotlin.test.Ignore
 import kotlin.test.Test
 
 class PropsTest {

lynglib/src/commonTest/kotlin/net/sergeych/lyng/StdlibExtensionWrapperCoverageTest.kt

@@ -1,55 +0,0 @@
-/*
- * Copyright 2026 Sergey S. Chernov
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package net.sergeych.lyng
-
-import kotlinx.coroutines.test.runTest
-import net.sergeych.lyng.miniast.BuiltinDocRegistry
-import net.sergeych.lyng.stdlib_included.rootLyng
-import kotlin.test.Test
-import kotlin.test.assertTrue
-
-class StdlibExtensionWrapperCoverageTest {
-    @Test
-    fun stdlibExtensionWrappersPresent() = runTest {
-        val src = rootLyng
-        val classNames = LinkedHashSet<String>()
-        val classRe = Regex(
-            "^\\s*(?:(?:abstract|override|closed|private|protected|static|open|extern)\\s+)*(?:fun|val|var)\\s+([A-Za-z_][A-Za-z0-9_]*)\\.",
-            RegexOption.MULTILINE
-        )
-        classRe.findAll(src).forEach { m ->
-            val name = m.groupValues.getOrNull(1)?.trim()
-            if (!name.isNullOrEmpty()) classNames.add(name)
-        }
-
-        val scope = Script.newScope()
-        val missing = mutableListOf<String>()
-        for (className in classNames) {
-            val members = BuiltinDocRegistry.extensionMemberNamesFor(className)
-            for (member in members) {
-                val callable = scope.get(extensionCallableName(className, member))
-                val getter = scope.get(extensionPropertyGetterName(className, member))
-                if (callable == null && getter == null) {
-                    missing += "$className.$member"
-                }
-            }
-        }
-
-        assertTrue(missing.isEmpty(), "Missing stdlib extension wrappers: ${missing.sorted()}")
-    }
-}

lynglib/src/commonTest/kotlin/net/sergeych/lyng/TransientTest.kt

@@ -24,13 +24,11 @@ import net.sergeych.lyng.obj.ObjNull
 import net.sergeych.lyng.obj.toBool
 import net.sergeych.lynon.lynonDecodeAny
 import net.sergeych.lynon.lynonEncodeAny
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 
-@Ignore
 class TransientTest {
 
     @Test

lynglib/src/commonTest/kotlin/net/sergeych/lyng/format/BlockReindentTest.kt

@@ -24,9 +24,7 @@ import kotlin.math.min
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
-import kotlin.test.Ignore
 
-@Ignore
 class BlockReindentTest {
     @Test
     fun findMatchingOpen_basic() {

lynglib/src/commonTest/kotlin/net/sergeych/lyng/format/LyngFormatterTest.kt

@@ -18,9 +18,7 @@ package net.sergeych.lyng.format
 
 import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.Ignore
 
-@Ignore
 class LyngFormatterTest {
 
     @Test

lynglib/src/commonTest/kotlin/net/sergeych/lyng/highlight/CommentEolTest.kt

@@ -20,9 +20,7 @@ package net.sergeych.lyng.highlight
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
-import kotlin.test.Ignore
 
-@Ignore
 class CommentEolTest {
 
     @Test

lynglib/src/commonTest/kotlin/net/sergeych/lyng/highlight/HighlightMappingTest.kt

@@ -19,9 +19,7 @@ package net.sergeych.lyng.highlight
 
 import kotlin.test.Test
 import kotlin.test.assertTrue
-import kotlin.test.Ignore
 
-@Ignore
 class HighlightMappingTest {
 
     private fun spansToLabeled(text: String, spans: List<HighlightSpan>): List<Pair<String, HighlightKind>> =

lynglib/src/commonTest/kotlin/net/sergeych/lyng/highlight/MapLiteralHighlightTest.kt

@@ -17,11 +17,9 @@
 
 package net.sergeych.lyng.highlight
 
-import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertTrue
 
-@Ignore
 class MapLiteralHighlightTest {
 
     private fun spansToLabeled(text: String, spans: List<HighlightSpan>): List<Pair<String, HighlightKind>> =

lynglib/src/commonTest/kotlin/net/sergeych/lyng/highlight/SourceOffsetTest.kt

@@ -25,9 +25,7 @@ import net.sergeych.lyng.Pos
 import net.sergeych.lyng.Source
 import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.Ignore
 
-@Ignore
 class SourceOffsetTest {
 
     @Test

lynglib/src/commonTest/kotlin/net/sergeych/lyng/miniast/ParamTypeInferenceTest.kt

@@ -19,8 +19,6 @@ package net.sergeych.lyng.miniast
 
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.Compiler
-import net.sergeych.lyng.Script
-import net.sergeych.lyng.Source
 import net.sergeych.lyng.binding.Binder
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -42,12 +40,7 @@ class ParamTypeInferenceTest {
         """.trimIndent()
 
         val sink = MiniAstBuilder()
-        Compiler.compileWithResolution(
+        Compiler.compileWithMini(code.trimIndent(), sink)
-            Source("<eval>", code.trimIndent()),
-            Script.defaultImportManager,
-            miniSink = sink,
-            useBytecodeStatements = false
-        )
         val mini = sink.build()!!
         val binding = Binder.bind(code, mini)