From 1c509ae77a98a954297dbb3deb46d9ed3f97f4e5 Mon Sep 17 00:00:00 2001
From: nikita-ty754 <nikitatishchenko1@gmail.com>
Date: Wed, 10 Dec 2025 13:52:20 +0200
Subject: [PATCH 1/6] - Update scala runtime including conversions, codecs and
 metadata - Codecs facade - Codecs registration - Remove imports from predef -
 Meta generation

---
 .../Generate__cs_adt__unwrapped_.xml          |   2 +-
 .../scala/io/septimalmind/baboon/Baboon.scala |   9 +-
 .../io/septimalmind/baboon/CLIOptions.scala   |  10 +
 .../scala/BaboonByteString.scala              | 275 +++++++++++
 .../baboon-runtime/scala/BaboonCodecs.scala   | 349 ++++++++++++++
 .../scala/BaboonCodecsFacade.scala            | 439 ++++++++++++++++++
 .../scala/BaboonConversions.scala             | 141 ++++++
 .../scala/BaboonExceptions.scala              |  20 +
 .../scala/BaboonFixtureShared.scala           | 105 +++++
 .../scala/BaboonRuntimeShared.scala           | 243 +++++++++-
 .../baboon-runtime/scala/BaboonTools.scala    | 311 +++++++++++++
 .../io/septimalmind/baboon/BaboonModule.scala |   1 +
 .../septimalmind/baboon/CompilerOptions.scala |   5 +
 .../translator/scl/ScBaboonTranslator.scala   |  95 ++--
 .../scl/ScCodecFixtureTranslator.scala        |  73 +--
 .../scl/ScCodecTestsTranslator.scala          |  16 +-
 .../translator/scl/ScCodecTranslator.scala    |   8 +-
 .../scl/ScConversionTranslator.scala          |  49 +-
 .../translator/scl/ScDefnTranslator.scala     | 176 ++++---
 .../translator/scl/ScDomainTreeTools.scala    |  87 ++++
 .../translator/scl/ScJsonCodecGenerator.scala | 266 +++++------
 .../baboon/translator/scl/ScTreeTools.scala   |   2 +-
 .../baboon/translator/scl/ScTypeInfo.scala    |   2 +-
 .../translator/scl/ScTypeTranslator.scala     |   4 +-
 .../baboon/translator/scl/ScTypes.scala       | 116 +++--
 .../translator/scl/ScUEBACodecGenerator.scala | 273 +++++------
 .../baboon/translator/scl/ScValue.scala       |   2 +-
 .../baboon/typer/model/DomainMember.scala     |   6 +
 28 files changed, 2528 insertions(+), 557 deletions(-)
 create mode 100644 baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonByteString.scala
 create mode 100644 baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecs.scala
 create mode 100644 baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecsFacade.scala
 create mode 100644 baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonConversions.scala
 create mode 100644 baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonExceptions.scala
 create mode 100644 baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonFixtureShared.scala
 mode change 120000 => 100644 baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonRuntimeShared.scala
 create mode 100644 baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonTools.scala
 create mode 100644 baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDomainTreeTools.scala

diff --git a/.idea/runConfigurations/Generate__cs_adt__unwrapped_.xml b/.idea/runConfigurations/Generate__cs_adt__unwrapped_.xml
index 41654ff7..ca0bca3f 100644
--- a/.idea/runConfigurations/Generate__cs_adt__unwrapped_.xml
+++ b/.idea/runConfigurations/Generate__cs_adt__unwrapped_.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="Generate (cs/adt: unwrapped)" type="Application" factoryName="Application">
     <option name="MAIN_CLASS_NAME" value="io.septimalmind.baboon.Baboon" />
     <module name="baboon-root.baboon.baboonJVM.main" />
-    <option name="PROGRAM_PARAMETERS" value="--model-dir=./baboon-compiler/src/test/resources/baboon/ --meta-write-evolution-json=baboon-meta.json :cs --output=./test/cs-stub/BaboonDefinitions/Generated --test-output=./test/cs-stub/BaboonTests/GeneratedTests --fixture-output=./test/cs-stub/BaboonTests/GeneratedFixtures --cs-wrapped-adt-branch-codecs=false --cs-write-evolution-dict=true --generate-ueba-codecs-by-default=true --generate-json-codecs-by-default=true :scala --output=./test/sc-stub/src/main/scala/generated-main --test-output=./test/sc-stub/src/test/scala/generated-tests --fixture-output=./test/sc-stub/src/main/scala/generated-fixtures --sc-write-evolution-dict=true --sc-wrapped-adt-branch-codecs=false" />
+    <option name="PROGRAM_PARAMETERS" value="--model-dir=./baboon-compiler/src/test/resources/baboon/ --meta-write-evolution-json=baboon-meta.json :cs --output=./test/cs-stub/BaboonDefinitions/Generated --test-output=./test/cs-stub/BaboonTests/GeneratedTests --fixture-output=./test/cs-stub/BaboonTests/GeneratedFixtures --cs-wrapped-adt-branch-codecs=false --cs-write-evolution-dict=true --generate-ueba-codecs-by-default=true --generate-json-codecs-by-default=true :scala --output=./test/sc-stub/src/main/scala/generated-main --test-output=./test/sc-stub/src/test/scala/generated-tests --fixture-output=./test/sc-stub/src/main/scala/generated-fixtures --sc-write-evolution-dict=true --sc-wrapped-adt-branch-codecs=false --generate-ueba-codecs-by-default=true --generate-json-codecs-by-default=true" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="io.septimalmind.baboon.*" />
diff --git a/baboon-compiler/.jvm/src/main/scala/io/septimalmind/baboon/Baboon.scala b/baboon-compiler/.jvm/src/main/scala/io/septimalmind/baboon/Baboon.scala
index 0f622051..72cf4a85 100644
--- a/baboon-compiler/.jvm/src/main/scala/io/septimalmind/baboon/Baboon.scala
+++ b/baboon-compiler/.jvm/src/main/scala/io/septimalmind/baboon/Baboon.scala
@@ -65,8 +65,13 @@ object Baboon {
                         output  = shopts.outOpts,
                         generic = shopts.genericOpts,
                         language = ScOptions(
-                          writeEvolutionDict     = opts.scWriteEvolutionDict.getOrElse(false),
-                          wrappedAdtBranchCodecs = opts.scWrappedAdtBranchCodecs.getOrElse(false),
+                          writeEvolutionDict          = opts.scWriteEvolutionDict.getOrElse(false),
+                          wrappedAdtBranchCodecs      = opts.scWrappedAdtBranchCodecs.getOrElse(false),
+                          enableDeprecatedEncoders    = opts.enableDeprecatedEncoders.getOrElse(false),
+                          generateJsonCodecs          = opts.generateJsonCodecs.getOrElse(true),
+                          generateUebaCodecs          = opts.generateUebaCodecs.getOrElse(true),
+                          generateJsonCodecsByDefault = opts.generateJsonCodecsByDefault.getOrElse(false),
+                          generateUebaCodecsByDefault = opts.generateUebaCodecsByDefault.getOrElse(false),
                         ),
                       )
                   }
diff --git a/baboon-compiler/.jvm/src/main/scala/io/septimalmind/baboon/CLIOptions.scala b/baboon-compiler/.jvm/src/main/scala/io/septimalmind/baboon/CLIOptions.scala
index 53fda68d..b65c6e67 100644
--- a/baboon-compiler/.jvm/src/main/scala/io/septimalmind/baboon/CLIOptions.scala
+++ b/baboon-compiler/.jvm/src/main/scala/io/septimalmind/baboon/CLIOptions.scala
@@ -68,6 +68,16 @@ case class ScCLIOptions(
   scWriteEvolutionDict: Option[Boolean],
   @HelpMessage("Every ADT branch will encode ADT metadata and expect it in the decoder")
   scWrappedAdtBranchCodecs: Option[Boolean],
+  @HelpMessage("Do not generate encoders for deprecated versions")
+  enableDeprecatedEncoders: Option[Boolean],
+  @HelpMessage("Generate JSON codecs")
+  generateJsonCodecs: Option[Boolean],
+  @HelpMessage("Generate UEBA codecs")
+  generateUebaCodecs: Option[Boolean],
+  @HelpMessage("Generate JSON codecs even for types without derived[json]")
+  generateJsonCodecsByDefault: Option[Boolean],
+  @HelpMessage("Generate UEBA codecs even for types without derived[ueba]")
+  generateUebaCodecsByDefault: Option[Boolean],
 ) extends SharedCLIOptions
 
 case class CLIOptions(
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonByteString.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonByteString.scala
new file mode 100644
index 00000000..21191d5e
--- /dev/null
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonByteString.scala
@@ -0,0 +1,275 @@
+package baboon.runtime.shared {
+
+  import java.nio.charset.{Charset, StandardCharsets}
+  import scala.annotation.tailrec
+  import scala.util.Try
+
+  /**
+   * Minimal immutable ByteString implementation with comparison and concatenation
+   */
+  class ByteString private (private val bytes: Array[Byte]) extends Ordered[ByteString] {
+
+    // Properties
+    def length: Int       = bytes.length
+    def isEmpty: Boolean  = bytes.isEmpty
+    def nonEmpty: Boolean = bytes.nonEmpty
+
+    // Indexed access
+    def apply(index: Int): Byte = bytes(index)
+
+    // Get a safe copy of the bytes
+    def toArray: Array[Byte] = bytes.clone()
+
+    // Direct access to underlying bytes - USE WITH CAUTION!
+    // Modifying the returned array will break immutability
+    def underlyingUnsafe: Array[Byte] = bytes
+
+    // Concatenation
+    def concat(other: ByteString): ByteString = {
+      if (other == null) throw new NullPointerException("Cannot concatenate with null")
+      val result = new Array[Byte](bytes.length + other.bytes.length)
+      System.arraycopy(bytes, 0, result, 0, bytes.length)
+      System.arraycopy(other.bytes, 0, result, bytes.length, other.bytes.length)
+      new ByteString(result)
+    }
+
+    def concat(others: ByteString*): ByteString = {
+      val totalLength = bytes.length + others.map(_.length).sum
+      val result      = new Array[Byte](totalLength)
+      var offset      = 0
+
+      System.arraycopy(bytes, 0, result, offset, bytes.length)
+      offset += bytes.length
+
+      others.foreach {
+        other =>
+          if (other != null) {
+            System.arraycopy(other.bytes, 0, result, offset, other.bytes.length)
+            offset += other.bytes.length
+          }
+      }
+
+      new ByteString(result)
+    }
+
+    // Operator for concatenation
+    def +(other: ByteString): ByteString  = concat(other)
+    def ++(other: ByteString): ByteString = concat(other)
+
+    // Comparison (for Ordered trait)
+    override def compare(that: ByteString): Int = {
+      if (that == null) return 1
+
+      val minLength = Math.min(bytes.length, that.bytes.length)
+      var i         = 0
+      while (i < minLength) {
+        val cmp = (bytes(i) & 0xFF) - (that.bytes(i) & 0xFF) // Unsigned comparison
+        if (cmp != 0) return cmp
+        i += 1
+      }
+      bytes.length - that.bytes.length
+    }
+
+    // Equality
+    override def equals(obj: Any): Boolean = obj match {
+      case null => false
+      case that: ByteString =>
+        if (this.bytes.length != that.bytes.length) false
+        else bytes.sameElements(that.bytes)
+      case _ => false
+    }
+
+    override def hashCode(): Int = {
+      var hash = 17
+      bytes.foreach {
+        b =>
+          hash = hash * 31 + b
+      }
+      hash
+    }
+
+    // String conversions
+    def toString(charset: Charset): String = new String(bytes, charset)
+    override def toString: String          = toString(StandardCharsets.UTF_8)
+
+    def toHexString: String = bytes.map("%02X".format(_)).mkString
+
+    // Substring operations
+    def substring(startIndex: Int, length: Int): ByteString = {
+      if (startIndex < 0 || startIndex >= bytes.length)
+        throw new IndexOutOfBoundsException(s"Start index: $startIndex")
+      if (length < 0 || startIndex + length > bytes.length)
+        throw new IndexOutOfBoundsException(s"Length: $length")
+
+      val result = new Array[Byte](length)
+      System.arraycopy(bytes, startIndex, result, 0, length)
+      new ByteString(result)
+    }
+
+    def slice(from: Int, until: Int): ByteString = {
+      substring(from, until - from)
+    }
+
+    def take(n: Int): ByteString = substring(0, Math.min(n, bytes.length))
+    def drop(n: Int): ByteString = substring(Math.min(n, bytes.length), Math.max(0, bytes.length - n))
+
+    def startsWith(other: ByteString): Boolean = {
+      if (other == null || other.length > length) false
+      else {
+        var i = 0
+        while (i < other.length) {
+          if (bytes(i) != other.bytes(i)) return false
+          i += 1
+        }
+        true
+      }
+    }
+
+    def endsWith(other: ByteString): Boolean = {
+      if (other == null || other.length > length) false
+      else {
+        val offset = length - other.length
+        var i      = 0
+        while (i < other.length) {
+          if (bytes(offset + i) != other.bytes(i)) return false
+          i += 1
+        }
+        true
+      }
+    }
+
+    // Functional operations
+    def map(f: Byte => Byte): ByteString = {
+      new ByteString(bytes.map(f))
+    }
+
+    def filter(f: Byte => Boolean): ByteString = {
+      new ByteString(bytes.filter(f))
+    }
+
+    def foreach(f: Byte => Unit): Unit = {
+      bytes.foreach(f)
+    }
+
+    def foldLeft[B](z: B)(f: (B, Byte) => B): B = {
+      bytes.foldLeft(z)(f)
+    }
+
+    def foldRight[B](z: B)(f: (Byte, B) => B): B = {
+      bytes.foldRight(z)(f)
+    }
+  }
+
+  /**
+   * ByteString companion object with factory methods
+   */
+  object ByteString {
+
+    // Factory methods
+    def apply(bytes: Array[Byte]): ByteString = {
+      if (bytes == null) throw new NullPointerException("bytes cannot be null")
+      new ByteString(bytes.clone()) // Clone to ensure immutability
+    }
+
+    def apply(bytes: Byte*): ByteString = {
+      new ByteString(bytes.toArray)
+    }
+
+    def apply(string: String, charset: Charset = StandardCharsets.UTF_8): ByteString = {
+      new ByteString(string.getBytes(charset))
+    }
+
+    def fromString(string: String, charset: Charset = StandardCharsets.UTF_8): ByteString = {
+      apply(string, charset)
+    }
+
+    // Static method to parse hex-encoded string into ByteString
+    def parseHex(hexString: String): ByteString = {
+      if (hexString == null)
+        throw new NullPointerException("hexString cannot be null")
+
+      // Remove common separators and whitespace
+      val cleanHex = hexString.replaceAll("[\\s:-]", "").trim
+
+      if (cleanHex.isEmpty)
+        return empty
+
+      if (cleanHex.length % 2 != 0)
+        throw new IllegalArgumentException(
+          s"Invalid hex string length: ${cleanHex.length}. Hex string must have even length."
+        )
+
+      try {
+        val bytes = cleanHex
+          .grouped(2).map {
+            byteStr =>
+              Integer.parseInt(byteStr, 16).toByte
+          }.toArray
+        new ByteString(bytes)
+      } catch {
+        case e: NumberFormatException =>
+          throw new IllegalArgumentException(s"Invalid hex characters in string: ${e.getMessage}", e)
+      }
+    }
+
+    // Try version that returns Try[ByteString]
+    def tryParse(hexString: String): Try[ByteString] = {
+      Try(parseHex(hexString))
+    }
+
+    // Empty ByteString singleton
+    val empty: ByteString = new ByteString(Array.empty[Byte])
+
+    // Builder for efficient concatenation
+    class Builder {
+      private val buffer = scala.collection.mutable.ArrayBuffer[Byte]()
+
+      def +=(b: Byte): this.type = {
+        buffer += b
+        this
+      }
+
+      def +=(bs: ByteString): this.type = {
+        buffer ++= bs.bytes
+        this
+      }
+
+      def ++=(bytes: Array[Byte]): this.type = {
+        buffer ++= bytes
+        this
+      }
+
+      def result(): ByteString = new ByteString(buffer.toArray)
+      def clear(): Unit        = buffer.clear()
+    }
+
+    def newBuilder: Builder = new Builder
+
+    // Implicit conversions (optional, use with care)
+    implicit class ByteStringOps(val sc: StringContext) extends AnyVal {
+      def bs(args: Any*): ByteString = {
+        val strings     = sc.parts.iterator
+        val expressions = args.iterator
+        val buf         = new StringBuilder(strings.next())
+
+        while (strings.hasNext) {
+          buf.append(expressions.next())
+          buf.append(strings.next())
+        }
+
+        ByteString(buf.toString())
+      }
+    }
+
+    // Utility methods
+    @tailrec
+    def concat(first: ByteString, others: ByteString*): ByteString = {
+      if (first == null) {
+        if (others.isEmpty) empty
+        else concat(others.head, others.tail: _*)
+      } else {
+        first.concat(others: _*)
+      }
+    }
+  }
+}
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecs.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecs.scala
new file mode 100644
index 00000000..997e9d63
--- /dev/null
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecs.scala
@@ -0,0 +1,349 @@
+package baboon.runtime.shared {
+
+  import io.circe.Json
+
+  import java.io.*
+  import java.nio.{ByteBuffer, ByteOrder}
+  import scala.collection.mutable
+  import scala.reflect.ClassTag
+
+  trait BaboonCodecData {
+    def baboonDomainVersion: String
+    def baboonDomainIdentifier: String
+    def baboonTypeIdentifier: String
+  }
+
+  trait BaboonCodecContext {
+    def useIndices: Boolean
+  }
+  object BaboonCodecContext {
+    val Default: BaboonCodecContext = Compact
+
+    object Indexed extends BaboonCodecContext {
+      override def useIndices: Boolean = true
+    }
+
+    object Compact extends BaboonCodecContext {
+      override def useIndices: Boolean = false
+    }
+  }
+
+  trait BaboonCodec[T] extends BaboonCodecData
+
+  trait BaboonValueCodec[T, TWire] extends BaboonCodec[T] {
+    def encode(ctx: BaboonCodecContext, instance: T): TWire
+    def decode(ctx: BaboonCodecContext, wire: TWire): Either[String, T]
+  }
+  trait BaboonStreamCodec[T, TOut, TIn] extends BaboonCodec[T] {
+    def encode(ctx: BaboonCodecContext, writer: TOut, instance: T): Unit
+    def decode(ctx: BaboonCodecContext, wire: TIn): T
+  }
+
+  trait BaboonJsonCodec[T] extends BaboonValueCodec[T, Json]
+
+  object BaboonJsonCodec {
+    trait BaboonGeneratedJsonCodec[T <: BaboonGenerated, TCodec <: BaboonJsonCodec[T]] {
+      self: Base[T, TCodec] =>
+      final def encode(ctx: BaboonCodecContext, instance: BaboonGenerated)(implicit t: ClassTag[T]): Json = {
+        instance match {
+          case v: T => self.encode(ctx, v)
+          case _    => throw new RuntimeException(s"Expected to have ${t.runtimeClass.getName} type")
+        }
+      }
+    }
+    trait Base[T, TCodec <: BaboonJsonCodec[T]] extends BaboonJsonCodec[T] with BaboonSingleton[TCodec]
+    trait BaseGenerated[T <: BaboonGenerated, TCodec <: BaboonJsonCodec[T]] extends Base[T, TCodec] with BaboonGeneratedJsonCodec[T, TCodec]
+    trait BaseGeneratedAdt[T <: BaboonGenerated, TCodec <: BaboonJsonCodec[T]] extends BaseGenerated[T, TCodec] with BaboonAdtMemberMeta
+    trait NoEncoder[T, TCodec <: BaboonJsonCodec[T]] extends Base[T, TCodec] {
+      override def encode(ctx: BaboonCodecContext, instance: T): Json = {
+        if (this ne LazyInstance.value) {
+          return LazyInstance.value.encode(ctx, instance)
+        }
+        throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
+      }
+    }
+    trait NoEncoderGenerated[T <: BaboonGenerated, TCodec <: BaboonJsonCodec[T]] extends BaseGenerated[T, TCodec] {
+      override def encode(ctx: BaboonCodecContext, instance: T): Json = {
+        if (this ne LazyInstance.value) {
+          return LazyInstance.value.encode(ctx, instance)
+        }
+        throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
+      }
+    }
+    trait NoEncoderGeneratedAdt[T <: BaboonGenerated, TCodec <: BaboonJsonCodec[T]] extends BaseGeneratedAdt[T, TCodec] {
+      override def encode(ctx: BaboonCodecContext, instance: T): Json = {
+        if (this ne LazyInstance.value) {
+          return LazyInstance.value.encode(ctx, instance)
+        }
+        throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
+      }
+    }
+  }
+
+  trait BaboonBinCodec[T] extends BaboonStreamCodec[T, LEDataOutputStream, LEDataInputStream]
+
+  object BaboonBinCodec {
+    trait BaboonGeneratedBinCodec[T <: BaboonGenerated, TCodec <: BaboonBinCodec[T]] {
+      self: Base[T, TCodec] =>
+      final def encode(ctx: BaboonCodecContext, writer: LEDataOutputStream, instance: BaboonGenerated)(implicit t: ClassTag[T]): Unit = {
+        instance match {
+          case v: T => self.encode(ctx, writer, v)
+          case _    => throw new RuntimeException(s"Expected to have ${t.runtimeClass.getName} type")
+        }
+      }
+    }
+    trait Base[T, TCodec <: BaboonBinCodec[T]] extends BaboonBinCodec[T] with BaboonSingleton[TCodec]
+    trait BaseGenerated[T <: BaboonGenerated, TCodec <: BaboonBinCodec[T]] extends Base[T, TCodec] with BaboonGeneratedBinCodec[T, TCodec]
+    trait BaseGeneratedAdt[T <: BaboonGenerated, TCodec <: BaboonBinCodec[T]] extends BaseGenerated[T, TCodec] with BaboonAdtMemberMeta
+    trait NoEncoder[T, TCodec <: BaboonBinCodec[T]] extends Base[T, TCodec] {
+      override def encode(ctx: BaboonCodecContext, writer: LEDataOutputStream, instance: T): Unit = {
+        if (this ne LazyInstance.value) {
+          LazyInstance.value.encode(ctx, writer, instance)
+        }
+        throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
+      }
+    }
+    trait NoEncoderGenerated[T <: BaboonGenerated, TCodec <: BaboonBinCodec[T]] extends BaseGenerated[T, TCodec] {
+      override def encode(ctx: BaboonCodecContext, writer: LEDataOutputStream, instance: T): Unit = {
+        if (this ne LazyInstance.value) {
+          LazyInstance.value.encode(ctx, writer, instance)
+        }
+        throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
+      }
+    }
+    trait NoEncoderGeneratedAdt[T <: BaboonGenerated, TCodec <: BaboonBinCodec[T]] extends BaseGeneratedAdt[T, TCodec] {
+      override def encode(ctx: BaboonCodecContext, writer: LEDataOutputStream, instance: T): Unit = {
+        if (this ne LazyInstance.value) {
+          LazyInstance.value.encode(ctx, writer, instance)
+        }
+        throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
+      }
+    }
+  }
+
+  case class BaboonIndexEntry(offset: Long, length: Long)
+
+  trait BaboonBinCodecIndexed {
+    def indexElementsCount(ctx: BaboonCodecContext): Short
+
+    def readIndex(ctx: BaboonCodecContext, wire: LEDataInputStream): List[BaboonIndexEntry] = {
+      val header           = wire.readByte()
+      val isIndexed        = (header & 0x01) != 0
+      val result           = scala.collection.mutable.ListBuffer.empty[BaboonIndexEntry]
+      var prevOffset: Long = 0L
+      var prevLen: Long    = 0L
+
+      if (isIndexed) {
+        var left = indexElementsCount(ctx).toInt
+        while (left > 0) {
+          val offset = wire.readInt()
+          val len    = wire.readInt()
+
+          require(len > 0, "Length must be positive")
+          require(offset >= prevOffset + prevLen, s"Offset violation: $offset not >= ${prevOffset + prevLen}")
+
+          result += BaboonIndexEntry(offset.toLong, len.toLong)
+          left       = left - 1
+          prevOffset = offset.toLong
+          prevLen    = len.toLong
+        }
+      }
+
+      result.toList
+    }
+  }
+
+  trait AbstractBaboonCodecs {
+    private val registry = mutable.Map.empty[String, Lazy[BaboonCodecData]]
+
+    def register[T](id: String, codec: Lazy[BaboonCodecData]): Unit = {
+      registry.put(id, codec)
+    }
+
+    def find(id: String): Lazy[BaboonCodecData] = {
+      registry(id)
+    }
+
+    def tryFind(id: String): Option[Lazy[BaboonCodecData]] = {
+      registry.get(id)
+    }
+  }
+
+  trait AbstractBaboonJsonCodecs extends AbstractBaboonCodecs
+  trait AbstractBaboonUebaCodecs extends AbstractBaboonCodecs
+
+  class LEDataInputStream(stream: InputStream) extends InputStream with DataInput {
+    private val dataIn           = new DataInputStream(stream)
+    private val buffer           = ByteBuffer.allocate(8)
+    private val order: ByteOrder = ByteOrder.LITTLE_ENDIAN
+
+    @throws[IOException]
+    override def read(b: Array[Byte]): Int = dataIn.read(b)
+
+    @throws[IOException]
+    override def read(b: Array[Byte], off: Int, len: Int): Int = dataIn.read(b, off, len)
+
+    @throws[IOException]
+    @deprecated("readLine() is deprecated", "1.0")
+    override def readLine(): String = dataIn.readLine()
+
+    @throws[IOException]
+    override def readBoolean(): Boolean = dataIn.readBoolean()
+
+    @throws[IOException]
+    override def readByte(): Byte = dataIn.readByte()
+
+    @throws[IOException]
+    override def read(): Int = readByte().toInt
+
+    override def markSupported(): Boolean = dataIn.markSupported()
+
+    override def mark(readlimit: Int): Unit = dataIn.mark(readlimit)
+
+    @throws[IOException]
+    override def reset(): Unit = dataIn.reset()
+
+    @throws[IOException]
+    override def readChar(): Char = dataIn.readChar()
+
+    @throws[IOException]
+    override def readFully(b: Array[Byte]): Unit = dataIn.readFully(b)
+
+    @throws[IOException]
+    override def readFully(b: Array[Byte], off: Int, len: Int): Unit = dataIn.readFully(b, off, len)
+
+    @throws[IOException]
+    override def readUTF(): String = dataIn.readUTF()
+
+    @throws[IOException]
+    override def skipBytes(n: Int): Int = dataIn.skipBytes(n)
+
+    @throws[IOException]
+    override def readDouble(): Double = {
+      val tmp = readLong()
+      java.lang.Double.longBitsToDouble(tmp)
+    }
+
+    @throws[IOException]
+    override def readFloat(): Float = {
+      val tmp = readInt()
+      java.lang.Float.intBitsToFloat(tmp)
+    }
+
+    @throws[IOException]
+    override def readInt(): Int = {
+      buffer.clear()
+      buffer
+        .order(ByteOrder.BIG_ENDIAN)
+        .putInt(dataIn.readInt())
+        .flip()
+      buffer.order(order).getInt()
+    }
+
+    @throws[IOException]
+    override def readLong(): Long = {
+      buffer.clear()
+      buffer
+        .order(ByteOrder.BIG_ENDIAN)
+        .putLong(dataIn.readLong())
+        .flip()
+      buffer.order(order).getLong()
+    }
+
+    @throws[IOException]
+    override def readShort(): Short = {
+      buffer.clear()
+      buffer
+        .order(ByteOrder.BIG_ENDIAN)
+        .putShort(dataIn.readShort())
+        .flip()
+      buffer.order(order).getShort()
+    }
+
+    @throws[IOException]
+    override def readUnsignedByte(): Int = dataIn.readByte() & 0xFF
+
+    @throws[IOException]
+    override def readUnsignedShort(): Int = readShort() & 0xFFFF
+  }
+
+  class LEDataOutputStream(stream: OutputStream) extends OutputStream with DataOutput {
+    private val dataOut          = new DataOutputStream(stream)
+    private val buffer           = ByteBuffer.allocate(8)
+    private val order: ByteOrder = ByteOrder.LITTLE_ENDIAN
+
+    // OutputStream implementation
+    @throws[IOException]
+    override def write(b: Int): Unit = dataOut.write(b)
+
+    @throws[IOException]
+    override def write(b: Array[Byte]): Unit = dataOut.write(b)
+
+    @throws[IOException]
+    override def write(b: Array[Byte], off: Int, len: Int): Unit =
+      dataOut.write(b, off, len)
+
+    @throws[IOException]
+    override def flush(): Unit = dataOut.flush()
+
+    @throws[IOException]
+    override def close(): Unit = dataOut.close()
+
+    // DataOutput implementation
+    @throws[IOException]
+    override def writeBoolean(v: Boolean): Unit = dataOut.writeBoolean(v)
+
+    @throws[IOException]
+    override def writeByte(v: Int): Unit = dataOut.writeByte(v)
+
+    @throws[IOException]
+    override def writeBytes(s: String): Unit = dataOut.writeBytes(s)
+
+    @throws[IOException]
+    override def writeChar(v: Int): Unit = {
+      buffer.clear()
+      buffer.order(order).putChar(v.toChar)
+      buffer.flip()
+      dataOut.write(buffer.array(), 0, 2)
+    }
+
+    @throws[IOException]
+    override def writeChars(s: String): Unit =
+      s.foreach(c => writeChar(c.toInt))
+
+    @throws[IOException]
+    override def writeDouble(v: Double): Unit =
+      writeLong(java.lang.Double.doubleToLongBits(v))
+
+    @throws[IOException]
+    override def writeFloat(v: Float): Unit =
+      writeInt(java.lang.Float.floatToIntBits(v))
+
+    @throws[IOException]
+    override def writeInt(v: Int): Unit = {
+      buffer.clear()
+      buffer.order(order).putInt(v)
+      buffer.flip()
+      dataOut.write(buffer.array(), 0, 4)
+    }
+
+    @throws[IOException]
+    override def writeLong(v: Long): Unit = {
+      buffer.clear()
+      buffer.order(order).putLong(v)
+      buffer.flip()
+      dataOut.write(buffer.array(), 0, 8)
+    }
+
+    @throws[IOException]
+    override def writeShort(v: Int): Unit = {
+      buffer.clear()
+      buffer.order(order).putShort(v.toShort)
+      buffer.flip()
+      dataOut.write(buffer.array(), 0, 2)
+    }
+
+    @throws[IOException]
+    override def writeUTF(s: String): Unit = dataOut.writeUTF(s)
+  }
+}
\ No newline at end of file
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecsFacade.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecsFacade.scala
new file mode 100644
index 00000000..5769af1b
--- /dev/null
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecsFacade.scala
@@ -0,0 +1,439 @@
+package baboon.runtime.shared {
+
+  import io.circe.Json
+
+  import java.io.{ByteArrayInputStream, ByteArrayOutputStream}
+  import scala.collection.concurrent.TrieMap
+  import scala.concurrent.ExecutionContext.Implicits.global
+  import scala.concurrent.Future
+  import scala.reflect.ClassTag
+  import scala.util.Try
+
+  trait BaboonCodecsFacade {
+    type BaboonValue[T] = Either[BaboonCodecException, T]
+
+    private val CONTENT_JSON_KEY = "$c"
+
+    private val versionsCodecsJson: TrieMap[BaboonDomainVersion, Lazy[AbstractBaboonJsonCodecs]]   = TrieMap.empty
+    private val versionsCodecsBin: TrieMap[BaboonDomainVersion, Lazy[AbstractBaboonUebaCodecs]]    = TrieMap.empty
+    private val versionsConversions: TrieMap[BaboonDomainVersion, Lazy[AbstractBaboonConversions]] = TrieMap.empty
+    private val versionsMeta: TrieMap[BaboonDomainVersion, Lazy[BaboonMeta]]                       = TrieMap.empty
+
+    private val domainVersions: TrieMap[String, List[BaboonDomainVersion]] = TrieMap.empty
+
+    def latest(domain: String): Version = {
+      domainVersions.get(domain).filter(_.nonEmpty) match {
+        case Some(versions) => versions.last.version
+        case None           => throw new Exception(s"No registered version for $domain domain found.")
+      }
+    }
+
+    def register(facade: BaboonCodecsFacade): Unit = {
+      facade.domainVersions.foreach { case (id, versions) => domainVersions.put(id, versions) }
+      facade.versionsCodecsJson.foreach { case (id, codec) => versionsCodecsJson.put(id, codec) }
+      facade.versionsCodecsBin.foreach { case (id, codec) => versionsCodecsBin.put(id, codec) }
+      facade.versionsConversions.foreach { case (id, conversion) => versionsConversions.put(id, conversion) }
+      facade.versionsMeta.foreach { case (id, meta) => versionsMeta.put(id, meta) }
+    }
+
+    def register(
+      domainVersion: BaboonDomainVersion,
+      codecsJson: => AbstractBaboonJsonCodecs,
+      codecsBin: => AbstractBaboonUebaCodecs,
+      conversions: => AbstractBaboonConversions,
+      meta: => BaboonMeta,
+    ): BaboonDomainVersion = {
+      register(domainVersion)
+      versionsCodecsJson.put(domainVersion, Lazy(codecsJson))
+      versionsCodecsBin.put(domainVersion, Lazy(codecsBin))
+      versionsConversions.put(domainVersion, Lazy(conversions))
+      versionsMeta.put(domainVersion, Lazy(meta))
+      domainVersion
+    }
+
+    def register(
+      domainVersion: BaboonDomainVersion,
+      codecsJson: => AbstractBaboonJsonCodecs,
+      codecsBin: => AbstractBaboonUebaCodecs,
+    ): BaboonDomainVersion = {
+      register(domainVersion)
+      versionsCodecsJson.put(domainVersion, Lazy(codecsJson))
+      versionsCodecsBin.put(domainVersion, Lazy(codecsBin))
+      domainVersion
+    }
+
+    def register(
+      domainVersion: BaboonDomainVersion,
+      codecsJson: => AbstractBaboonJsonCodecs,
+      codecsBin: => AbstractBaboonUebaCodecs,
+      meta: => BaboonMeta,
+    ): BaboonDomainVersion = {
+      register(domainVersion)
+      versionsCodecsJson.put(domainVersion, Lazy(codecsJson))
+      versionsCodecsBin.put(domainVersion, Lazy(codecsBin))
+      versionsMeta.put(domainVersion, Lazy(meta))
+      domainVersion
+    }
+
+    def register(
+      domainVersion: BaboonDomainVersion,
+      conversions: => AbstractBaboonConversions,
+    ): BaboonDomainVersion = {
+      register(domainVersion)
+      versionsConversions.put(domainVersion, Lazy(conversions))
+      domainVersion
+    }
+
+    def register(
+      domainVersion: BaboonDomainVersion,
+      meta: => BaboonMeta,
+    )(implicit d: DummyImplicit
+    ): BaboonDomainVersion = {
+      register(domainVersion)
+      versionsMeta.put(domainVersion, Lazy(meta))
+      domainVersion
+    }
+
+    def preload(): Unit = {
+      Future {
+        versionsCodecsJson.values.foreach(_.value)
+        versionsCodecsBin.values.foreach(_.value)
+      }.recover(_ => ())
+    }
+
+    def verify(): Unit = {
+      if (domainVersions.isEmpty) {
+        throw new Exception("Baboon codecs must have at least one domain registered.")
+      }
+
+      domainVersions.flatMap(_._2).foreach {
+        domainVersion =>
+          if (!versionsConversions.contains(domainVersion)) {
+            throw BaboonCodecException.ConversionNotFound(s"Baboon codecs must have conversion for $domainVersion registered.")
+          }
+          if (!versionsMeta.contains(domainVersion)) {
+            throw BaboonCodecException.CodecNotFound(s"Baboon codecs must have codecs for $domainVersion registered.")
+          }
+      }
+    }
+
+    def tryConvert[TI <: BaboonGenerated, TO <: BaboonGeneratedLatest](value: TI): Option[TO] = {
+      convert(value).toOption
+    }
+
+    def encodeToBin[T <: BaboonGenerated: ClassTag](
+      ctx: BaboonCodecContext,
+      value: T,
+    ): BaboonValue[Array[Byte]] = {
+      encodeToBin(ctx, value, None)
+    }
+
+    def encodeToBin[T <: BaboonGenerated: ClassTag](
+      ctx: BaboonCodecContext,
+      value: T,
+      typeMetaOverride: Option[BaboonTypeMeta],
+    ): BaboonValue[Array[Byte]] = {
+      val byteStream = new ByteArrayOutputStream()
+      val ledStream  = new LEDataOutputStream(byteStream)
+      encodeToBin(ctx, ledStream, value, typeMetaOverride).map(_ => byteStream.toByteArray)
+    }
+
+    def encodeToBin[T <: BaboonGenerated: ClassTag](
+      ctx: BaboonCodecContext,
+      writer: LEDataOutputStream,
+      value: T,
+    ): BaboonValue[Unit] = {
+      encodeToBin(ctx, writer, value, None)
+    }
+
+    def encodeToBin[T <: BaboonGenerated: ClassTag](
+      ctx: BaboonCodecContext,
+      writer: LEDataOutputStream,
+      value: T,
+      typeMetaOverride: Option[BaboonTypeMeta],
+    ): BaboonValue[Unit] = {
+      val typeMeta = BaboonTypeMeta.from(value)
+      (for {
+        codec <- getBinCodec(typeMeta, exact = true).toTry
+        _     <- Try(typeMetaOverride.getOrElse(typeMeta).writeBin(writer))
+        _     <- Try(codec.encode(ctx, writer, value))
+      } yield ()).toEither.left.map(
+        e =>
+          BaboonCodecException.EncoderFailure(
+            s"Exception while trying to encode to binary form type [${typeMeta.domainVersion}.${typeMeta.typeIdentifier}] of version '${typeMeta.domainVersion}'.",
+            e,
+          )
+      )
+    }
+
+    def decodeFromBin(reader: LEDataInputStream): BaboonValue[BaboonGenerated] = {
+      for {
+        typeMeta <- BaboonTypeMeta
+          .readMeta(reader)
+          .toRight(BaboonCodecException.DecoderFailure("Cannot decode binary type meta"))
+
+        codec <- getBinCodec(typeMeta, exact = false)
+        baboon <- Try(codec.decode(BaboonCodecContext.Compact, reader)).toEither.left.map(
+          e =>
+            BaboonCodecException.DecoderFailure(
+              s"Can not decode BIN form type [${typeMeta.domainIdentifier}.${typeMeta.typeIdentifier}] of version '${typeMeta.domainVersion}'.",
+              e,
+            )
+        )
+      } yield baboon
+    }
+
+    def decodeFromBin(bytes: Array[Byte]): BaboonValue[BaboonGenerated] = {
+      val byteInputStream = new ByteArrayInputStream(bytes)
+      val ledInputStream  = new LEDataInputStream(byteInputStream)
+      decodeFromBin(ledInputStream)
+    }
+
+    def decodeFromBinLatest(bytes: Array[Byte]): BaboonValue[BaboonGeneratedLatest] = {
+      decodeFromBin(bytes).flatMap(baboon => convert[BaboonGenerated, BaboonGeneratedLatest](baboon))
+    }
+
+    def decodeFromBinLatest[T <: BaboonGeneratedLatest: ClassTag](reader: LEDataInputStream): BaboonValue[T] = {
+      decodeFromBin(reader).flatMap(baboon => convert[BaboonGenerated, T](baboon))
+    }
+
+    def decodeFromBinLatest[T <: BaboonGeneratedLatest: ClassTag](bytes: Array[Byte]): BaboonValue[T] = {
+      decodeFromBin(bytes).flatMap(baboon => convert[BaboonGenerated, T](baboon))
+    }
+
+    def encodeToJson[T <: BaboonGenerated: ClassTag](value: T, typeMetaOverride: Option[BaboonTypeMeta]): BaboonValue[Json] = {
+      val typeMeta = BaboonTypeMeta.from(value)
+      (for {
+        jsonCodec  <- getJsonCodec(typeMeta, exact = true).toTry
+        jsonContent = jsonCodec.encode(BaboonCodecContext.Compact, value)
+        metaJson    = typeMetaOverride.getOrElse(typeMeta).writeJson
+        result      = jsonContent.mapObject(_.add(CONTENT_JSON_KEY, metaJson))
+      } yield result).toEither.left.map(
+        e =>
+          BaboonCodecException.EncoderFailure(
+            s"Can not encode to json form type [${value.baboonTypeIdentifier}] of version '${value.domainVersion}'.",
+            e,
+          )
+      )
+    }
+
+    def encodeToJson[T <: BaboonGenerated: ClassTag](value: T): BaboonValue[Json] = {
+      encodeToJson(value, None)
+    }
+
+    def encodeToJsonString[T <: BaboonGenerated: ClassTag](value: T, typeMetaOverride: Option[BaboonTypeMeta]): BaboonValue[String] = {
+      encodeToJson(value, typeMetaOverride).map(_.noSpaces)
+    }
+
+    def encodeToJsonString[T <: BaboonGenerated: ClassTag](value: T): BaboonValue[String] = {
+      encodeToJsonString(value, None)
+    }
+
+    def decodeFromJson(value: Json): BaboonValue[Option[BaboonGenerated]] = {
+      // This must be a proper, previously serialized baboon object, keep it as is.
+      val maybeTypeMeta     = BaboonTypeMeta.readMeta(value)
+      val maybeContentToken = value.hcursor.downField(CONTENT_JSON_KEY).as[Json].toOption
+      (maybeTypeMeta, maybeContentToken) match {
+        case (Some(typeMeta), Some(contentToken)) =>
+          for {
+            jsonCodec <- getJsonCodec(typeMeta, exact = false)
+            baboon    <- jsonCodec.decode(BaboonCodecContext.Compact, contentToken)
+          } yield baboon
+          Try(getJsonCodec(typeMeta, exact = false).flatMap(_.decode(BaboonCodecContext.Compact, contentToken))).toEither.left
+            .map(
+              e =>
+                BaboonCodecException.DecoderFailure(
+                  s"Can not decode JSON form type [${typeMeta.domainVersion}.${typeMeta.typeIdentifier}] of version '${typeMeta.domainVersion}'. JSON: $value",
+                  e,
+                )
+            ).map(_.toOption)
+        case _ => Right(None)
+      }
+    }
+
+    def decodeFromJson(value: String): BaboonValue[Option[BaboonGenerated]] = {
+      val json = io.circe.parser.parse(value).toOption.get
+      decodeFromJson(json)
+    }
+
+    def decodeFromJsonLatest(value: String): BaboonValue[Option[BaboonGenerated]] = {
+      decodeFromJson(value).flatMap(
+        _.fold[Either[BaboonCodecException, Option[BaboonGenerated]]](Right(None))(v => convert[BaboonGenerated, BaboonGeneratedLatest](v).map(Some(_)))
+      )
+    }
+
+    def decodeFromJsonLatest[T <: BaboonGeneratedLatest: ClassTag](value: String): BaboonValue[Option[T]] = {
+      decodeFromJson(value).flatMap(
+        _.fold[Either[BaboonCodecException, Option[T]]](Right(None))(v => convert[BaboonGenerated, T](v).map(Some(_)))
+      )
+    }
+
+    def decodeFromJsonLatest[T <: BaboonGeneratedLatest: ClassTag](value: Json): BaboonValue[Option[T]] = {
+      decodeFromJson(value).flatMap(
+        _.fold[Either[BaboonCodecException, Option[T]]](Right(None))(v => convert[BaboonGenerated, T](v).map(Some(_)))
+      )
+    }
+
+    def convert[From <: BaboonGenerated, TO <: BaboonGeneratedLatest](
+      value: From
+    )(implicit ctTo: ClassTag[TO]
+    ): BaboonValue[TO] = {
+      def isAdtConversion(instance: BaboonGenerated, conversion: Conversion): Boolean = {
+        instance match {
+          case adt: BaboonAdtMemberMeta => adt.baboonAdtType == conversion.typeFrom
+          case _                        => false
+        }
+      }
+
+      def tryConvert(versions: List[BaboonDomainVersion]): BaboonValue[BaboonGenerated] = {
+        // iterate from first to the latest version, trying to apply conversions
+        versions.foldLeft[Either[BaboonCodecException, BaboonGenerated]](Right(value)) {
+          case (fromModel, toVersion) =>
+            if (fromModel.exists(_.domainVersion.version >= toVersion.version)) {
+              // our model version is higher or the same as this one
+              fromModel
+            } else {
+              for {
+                fromModel       <- fromModel
+                lazyConversions <- versionsConversions.get(toVersion).toRight(BaboonCodecException.ConverterFailure(s"Can not find version '$toVersion' conversions."))
+                typeConversions  = lazyConversions.value.findConversions(fromModel)
+                maybeConversion = typeConversions
+                  .filter(typeConversion => fromModel.getClass == typeConversion.typeFrom || isAdtConversion(fromModel, typeConversion))
+                  .maxByOption(conversion => Version.from(conversion.versionTo))
+                conversion <- maybeConversion.toRight(
+                  BaboonCodecException.ConverterFailure(s"Can not find version '$toVersion' type [${fromModel.getClass.getName}] conversions.")
+                )
+                result <- Try(lazyConversions.value.convert(fromModel, conversion)).toEither.left.map(
+                  e =>
+                    BaboonCodecException.ConverterFailure(
+                      s"Exception while converting type [${fromModel.getClass.getName}] of version '${fromModel.domainVersion}' to version '$toVersion'.",
+                      e,
+                    )
+                )
+              } yield result
+            }
+        }
+      }
+
+      value match {
+        case to: TO => Right(to)
+        case _ =>
+          val domainVersion = value.domainVersion
+          for {
+            versions <- domainVersions
+              .get(domainVersion.domainIdentifier)
+              .filter(_.nonEmpty)
+              .toRight(BaboonCodecException.ConverterFailure(s"Unknown domain '${domainVersion.domainIdentifier}'."))
+
+            _         <- versions.find(_ == domainVersion).toRight(BaboonCodecException.ConverterFailure(s"Unknown domain version' $domainVersion'."))
+            converted <- tryConvert(versions)
+            result <- converted match {
+              case io: TO => Right(io)
+              case _ =>
+                Left(
+                  BaboonCodecException.ConverterFailure(
+                    s"Expected to have type [${ctTo.runtimeClass.getName}] at the end, but got [${converted.getClass.getName}]."
+                  )
+                )
+            }
+          } yield result
+      }
+    }
+
+    private def getBinCodec(typeMeta: BaboonTypeMeta, exact: Boolean): BaboonValue[BaboonBinCodec[BaboonGenerated]] = {
+      getCodec(versionsCodecsBin, typeMeta, exact).map(_.asInstanceOf[BaboonBinCodec[BaboonGenerated]])
+    }
+
+    private def getJsonCodec(typeMeta: BaboonTypeMeta, exact: Boolean): BaboonValue[BaboonJsonCodec[BaboonGenerated]] = {
+      getCodec(versionsCodecsJson, typeMeta, exact).map(_.asInstanceOf[BaboonJsonCodec[BaboonGenerated]])
+    }
+
+    private def getCodec[TCodecs <: AbstractBaboonCodecs](
+      versionsCodecs: TrieMap[BaboonDomainVersion, Lazy[TCodecs]],
+      typeMeta: BaboonTypeMeta,
+      exact: Boolean,
+    ): BaboonValue[BaboonCodecData] = {
+      for {
+        versions <- domainVersions
+          .get(typeMeta.domainIdentifier)
+          .filter(_.nonEmpty)
+          .toRight(BaboonCodecException.CodecNotFound(s"Unknown domain ${typeMeta.domainIdentifier}."))
+
+        minVersion = versions.head
+        maxVersion = versions.last
+        // extract domain model version and latest version
+        modelVersion = typeMeta.versionMinCompat match {
+          // it's a model of newer version than we have, we should find min compat version
+          case Some(v) if typeMeta.version.version > maxVersion.version => v
+          case _                                                        => typeMeta.version
+        }
+
+        codec <- modelVersion match {
+          // it's a model of latest version, get last version codec
+          case v if exact && v.version == maxVersion.version =>
+            getCodecExact(versionsCodecs, modelVersion, typeMeta.typeIdentifier)
+          // it's a model of outdated version, we should read it with max compat codec
+          case v if v.version >= minVersion.version && v.version < maxVersion.version =>
+            getCodecMaxCompat(versionsCodecs, modelVersion, maxVersion, typeMeta.typeIdentifier)
+          // it's a model of deprecated version, we should try to decode with minimal version
+          case v if v.version < minVersion.version =>
+            getCodecMaxCompat(versionsCodecs, minVersion, maxVersion, typeMeta.typeIdentifier)
+          case _ => Left(BaboonCodecException.CodecNotFound(s"Unsupported domain version '$modelVersion'."))
+        }
+      } yield codec
+    }
+
+    private def getCodecExact[TCodecs <: AbstractBaboonCodecs](
+      versionsCodecs: TrieMap[BaboonDomainVersion, Lazy[TCodecs]],
+      domainVersion: BaboonDomainVersion,
+      typeIdentifier: String,
+    ): BaboonValue[BaboonCodecData] = {
+      for {
+        lazyVersionCodecs <- versionsCodecs
+          .get(domainVersion)
+          .toRight(BaboonCodecException.CodecNotFound(s"No codecs registered for domain version '$domainVersion'."))
+        codec <- lazyVersionCodecs.value
+          .tryFind(typeIdentifier)
+          .map(_.value)
+          .toRight(BaboonCodecException.CodecNotFound(s"No codec found for type [${domainVersion.domainVersion}.$typeIdentifier] of version '${domainVersion.version}'."))
+      } yield codec
+    }
+
+    private def getCodecMaxCompat[TCodecs <: AbstractBaboonCodecs](
+      versionsCodecs: TrieMap[BaboonDomainVersion, Lazy[TCodecs]],
+      modelVersion: BaboonDomainVersion,
+      maxVersion: BaboonDomainVersion,
+      typeIdentifier: String,
+    ): BaboonValue[BaboonCodecData] = {
+      (for {
+        lazyDomainMeta <- versionsMeta
+          .get(modelVersion)
+          .toRight(BaboonCodecException.CodecNotFound(s"Unknown domain version '{$modelVersion}'."))
+
+        // version is registered, and we can read it with max compat codec
+        // scan same versions from max to min, to find max compat version
+        sameVersions = lazyDomainMeta.value.sameInVersions(typeIdentifier)
+        maybeCodec = sameVersions
+          .findLast(sameVersion => sameVersion == maxVersion.domainVersion || Version.from(sameVersion) <= maxVersion.version).map {
+            sameVersion =>
+              val maxCompatVersion = BaboonDomainVersion(modelVersion.domainIdentifier, sameVersion)
+              getCodecExact(versionsCodecs, maxCompatVersion, typeIdentifier)
+          }
+        codec <- maybeCodec.toRight(
+          BaboonCodecException.CodecNotFound(
+            s"No max compat codec found for type [${modelVersion.domainIdentifier}.{$typeIdentifier}] of version '${modelVersion.version}'."
+          )
+        )
+      } yield codec).flatten
+    }
+
+    private def register(domainVersion: BaboonDomainVersion): BaboonDomainVersion = {
+      domainVersions
+        .updateWith(domainVersion.domainIdentifier) {
+          case Some(versions) => Some(if (versions.contains(domainVersion)) versions else versions.appended(domainVersion).sortBy(_.version))
+          case None           => Some(List(domainVersion))
+        }
+      domainVersion
+    }
+  }
+}
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonConversions.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonConversions.scala
new file mode 100644
index 00000000..d2a45558
--- /dev/null
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonConversions.scala
@@ -0,0 +1,141 @@
+package baboon.runtime.shared {
+
+  import scala.collection.mutable
+  import scala.reflect.ClassTag
+
+  trait Conversion {
+    def typeFrom: Class[?]
+    def versionFrom: String
+
+    def typeTo: Class[?]
+    def versionTo: String
+
+    def typeId: String
+  }
+
+  trait BaboonGeneratedConversion extends Conversion {
+    def convert[C](context: Option[C], conversions: AbstractBaboonConversions, from: BaboonGenerated): BaboonGenerated
+  }
+
+  abstract class AbstractConversion[From, To](
+    implicit fromTag: ClassTag[From],
+    toTag: ClassTag[To],
+  ) extends BaboonGeneratedConversion {
+    protected def doConvert[Ctx](context: Option[Ctx], conversions: AbstractBaboonConversions, from: From): To
+
+    private def validateBaboonType(obj: Any): Unit = {
+      obj match {
+        case bg: BaboonGenerated =>
+          val conversionTypeIsExactType = typeId == bg.baboonTypeIdentifier
+          bg match {
+            case bga: BaboonAdtMemberMeta =>
+              val conversionTypeIsAdtType = typeId == bga.baboonAdtTypeIdentifier
+              if (!conversionTypeIsAdtType && !conversionTypeIsExactType) {
+                throw new IllegalArgumentException(
+                  s"Provided instance is adt=${bga.baboonAdtTypeIdentifier} exact=${bg.baboonTypeIdentifier}, one of which must be $typeId"
+                )
+              }
+            case _ =>
+              if (!conversionTypeIsExactType) {
+                throw new IllegalArgumentException(
+                  s"Provided instance is ${bg.baboonTypeIdentifier} but must be $typeId"
+                )
+              }
+          }
+        case _ =>
+      }
+    }
+
+    def convert[Ctx](context: Option[Ctx], conversions: AbstractBaboonConversions, from: From): To = {
+      validateBaboonType(from)
+      val result = doConvert(context, conversions, from)
+      validateBaboonType(result)
+      result
+    }
+
+    override def convert[Ctx](context: Option[Ctx], conversions: AbstractBaboonConversions, from: BaboonGenerated): BaboonGenerated = {
+      from match {
+        case f: From =>
+          val res = convert[Ctx](context, conversions, f)
+          res match {
+            case bg: BaboonGenerated => bg
+            case _ =>
+              throw new IllegalArgumentException(
+                s"Can't use IBaboonGeneratedConversion interface for non IBaboonGenerated return type To = ${typeTo.getName}"
+              )
+          }
+
+        case _ =>
+          throw new Exception(
+            s"Can't use IBaboonGeneratedConversion interface when 'from' is not of type ${typeFrom.getName}"
+          )
+      }
+    }
+
+    override final def typeFrom: Class[?] = fromTag.runtimeClass
+    override final def typeTo: Class[?]   = toTag.runtimeClass
+  }
+
+  case class ConversionKey(from: Class[?], to: Class[?])
+
+  trait AbstractBaboonConversions {
+    private val conversions     = mutable.Map.empty[ConversionKey, Conversion]
+    private val typeConversions = mutable.Map.empty[Class[?], List[Conversion]]
+
+    def register[F, T](
+      conversion: AbstractConversion[F, T]
+    )(implicit
+      tagF: ClassTag[F],
+      tagT: ClassTag[T],
+    ): Unit = {
+      val fromClass       = tagF.runtimeClass
+      val toClass         = tagT.runtimeClass
+      val key             = ConversionKey(fromClass, toClass)
+      val fromConversions = typeConversions.getOrElse(fromClass, Nil)
+      conversions.update(key, conversion)
+      typeConversions.update(fromClass, fromConversions.appended(conversion))
+    }
+
+    def convertWithContext[C](ctx: Option[C], from: BaboonGenerated, conversion: Conversion): BaboonGenerated = {
+      conversion.asInstanceOf[BaboonGeneratedConversion].convert(ctx, this, from)
+    }
+
+    def convert(from: BaboonGenerated, conversion: Conversion): BaboonGenerated = {
+      conversion.asInstanceOf[BaboonGeneratedConversion].convert(None, this, from)
+    }
+
+    def convertWithContext[C, F, T](
+      context: Option[C],
+      from: F,
+    )(implicit
+      tagF: ClassTag[F],
+      tagT: ClassTag[T],
+    ): T = {
+      val key = ConversionKey(tagF.runtimeClass, tagT.runtimeClass)
+      conversions(key).asInstanceOf[AbstractConversion[F, T]].convert[C](context, this, from)
+    }
+
+    def convert[F <: BaboonGenerated, T <: BaboonGenerated](
+      from: F
+    )(implicit
+      tagF: ClassTag[F],
+      tagT: ClassTag[T],
+    ): T = {
+      convertWithContext[Any, F, T](None, from)(tagF, tagT)
+    }
+
+    def findConversions(value: BaboonGenerated): List[Conversion] = {
+      typeConversions.get(implicitly[ClassTag[BaboonGenerated]].runtimeClass) match {
+        case Some(value) => value
+        case None =>
+          value match {
+            case m: BaboonAdtMemberMeta => typeConversions.getOrElse(m.baboonAdtType, Nil)
+            case _                      => Nil
+          }
+      }
+    }
+
+    def versionsFrom: List[String]
+    def versionTo: String
+  }
+}
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonExceptions.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonExceptions.scala
new file mode 100644
index 00000000..915103a1
--- /dev/null
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonExceptions.scala
@@ -0,0 +1,20 @@
+package baboon.runtime.shared {
+
+  trait BaboonCodecException extends Exception {
+    def message: String
+    override def getMessage: String = message
+  }
+
+  object BaboonCodecException {
+
+    final case class EncoderFailure(message: String, cause: Throwable = null) extends Exception(message, cause) with BaboonCodecException
+
+    final case class DecoderFailure(message: String, cause: Throwable = null) extends Exception(message, cause) with BaboonCodecException
+
+    final case class ConverterFailure(message: String, cause: Throwable = null) extends Exception(message, cause) with BaboonCodecException
+
+    final case class CodecNotFound(message: String) extends Exception(message) with BaboonCodecException
+
+    final case class ConversionNotFound(message: String) extends Exception(message) with BaboonCodecException
+  }
+}
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonFixtureShared.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonFixtureShared.scala
new file mode 100644
index 00000000..c9ed93c3
--- /dev/null
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonFixtureShared.scala
@@ -0,0 +1,105 @@
+package baboon.fixture {
+
+  import baboon.runtime.shared.{BaboonEnum, ByteString}
+
+  import java.math.BigDecimal
+  import java.time.{Instant, OffsetDateTime, ZoneOffset}
+
+  trait BaboonRandom {
+    def nextBit(): Boolean
+
+    def nextI08(): Byte
+    def nextI16(): Short
+    def nextI32(): Int
+    def nextI64(): Long
+
+    def nextU08(): Byte
+    def nextU16(): Short
+    def nextU32(): Int
+    def nextU64(): Long
+
+    def nextF32(): Float
+    def nextF64(): Double
+    def nextF128(): BigDecimal
+
+    def nextTsu(): OffsetDateTime
+    def nextTso(): OffsetDateTime
+
+    def nextUid(): java.util.UUID
+    def nextString(): String
+    def nextByteString(): ByteString
+
+    def mkOption[T](element: => T): Option[T]
+    def mkEnum[T](meta: BaboonEnum[T]): T
+    def mkList[T](element: => T): List[T]
+    def mkSet[T](element: => T): Set[T]
+    def mkMap[K, V](k: => K, v: => V): Map[K, V]
+
+    def oneOf[T](elements: List[BaboonRandom => T]): T
+    def randomElement[T](elements: List[T]): T
+  }
+
+  object BaboonRandom {
+    def default(): BaboonRandom = {
+      new BaboonRandomImpl(scala.util.Random)
+    }
+  }
+
+  class BaboonRandomImpl(rnd: scala.util.Random) extends BaboonRandom {
+    def nextBit(): Boolean = rnd.nextBoolean()
+
+    def nextI08(): Byte  = rnd.nextInt().toByte
+    def nextI16(): Short = rnd.nextInt().toShort
+    def nextI32(): Int   = rnd.nextInt().toInt
+    def nextI64(): Long  = rnd.nextInt().toLong
+
+    def nextU08(): Byte  = rnd.nextInt().toByte
+    def nextU16(): Short = rnd.nextInt().toShort
+    def nextU32(): Int   = rnd.nextInt().toInt
+    def nextU64(): Long  = rnd.nextInt().toLong
+
+    def nextF32(): Float       = rnd.nextFloat()
+    def nextF64(): Double      = rnd.nextDouble()
+    def nextF128(): BigDecimal = scala.math.BigDecimal(rnd.nextDouble()).bigDecimal
+
+    val earliest: OffsetDateTime = OffsetDateTime.parse("2020-01-01T00:00:00Z")
+    val latest: OffsetDateTime   = OffsetDateTime.parse("2099-12-31T23:59:59Z")
+
+    def generateRandomOffsetDateTime(startInclusive: OffsetDateTime, endInclusive: OffsetDateTime): OffsetDateTime = {
+      val minSeconds    = startInclusive.toEpochSecond
+      val maxSeconds    = endInclusive.toEpochSecond
+      val randomSeconds = minSeconds + rnd.nextLong(maxSeconds - minSeconds)
+      OffsetDateTime.ofInstant(Instant.ofEpochSecond(randomSeconds), ZoneOffset.UTC)
+    }
+    def nextTsu(): OffsetDateTime = {
+      generateRandomOffsetDateTime(earliest, latest).withOffsetSameInstant(ZoneOffset.UTC)
+    }
+    def nextTso(): OffsetDateTime = {
+      generateRandomOffsetDateTime(earliest, latest).withOffsetSameInstant(ZoneOffset.ofHours(rnd.nextInt(36) - 18))
+    }
+
+    def nextUid(): java.util.UUID = java.util.UUID.randomUUID()
+    def nextString(): String      = rnd.alphanumeric.take(10).mkString
+    def nextByteString(): ByteString = {
+      val length = rnd.nextInt(21)
+      val bytes  = new Array[Byte](length)
+      rnd.nextBytes(bytes)
+      ByteString(bytes)
+    }
+
+    def mkList[T](element: => T): List[T]        = rnd.shuffle(List.fill(rnd.nextInt(20))(element))
+    def mkSet[T](element: => T): Set[T]          = rnd.shuffle(Set.fill(rnd.nextInt(20))(element))
+    def mkMap[K, V](k: => K, v: => V): Map[K, V] = rnd.shuffle(List.fill(rnd.nextInt(20))((k, v)).toMap)
+    def mkOption[T](element: => T): Option[T]    = Some(element)
+
+    def mkEnum[T](meta: BaboonEnum[T]): T = rnd.shuffle(meta.all).head
+
+    def oneOf[T](elements: List[BaboonRandom => T]): T = {
+      elements(rnd.nextInt(elements.size))(this)
+    }
+
+    def randomElement[T](elements: List[T]): T = {
+      elements(rnd.nextInt(elements.size))
+    }
+  }
+}
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonRuntimeShared.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonRuntimeShared.scala
deleted file mode 120000
index d234056b..00000000
--- a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonRuntimeShared.scala
+++ /dev/null
@@ -1 +0,0 @@
-../../../scala/baboon/runtime/shared/BaboonRuntimeShared.scala
\ No newline at end of file
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonRuntimeShared.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonRuntimeShared.scala
new file mode 100644
index 00000000..950eb20b
--- /dev/null
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonRuntimeShared.scala
@@ -0,0 +1,242 @@
+package baboon.runtime.shared {
+
+  import baboon.runtime.shared.BaboonTypeMetaCodec.META_VERSION
+  import io.circe.{DecodingFailure, Json}
+
+  import java.util.concurrent.atomic.AtomicReference
+  import scala.reflect.ClassTag
+  import scala.util.{Success, Try}
+
+  trait BaboonGenerated {
+    def baboonDomainVersion: String
+    def baboonDomainIdentifier: String
+    def baboonSameInVersions: List[String]
+    def baboonTypeIdentifier: String
+
+    final def domainVersion: BaboonDomainVersion = BaboonDomainVersion(baboonDomainIdentifier, baboonDomainVersion)
+  }
+
+  trait BaboonGeneratedLatest extends BaboonGenerated
+
+  trait BaboonAdtMemberMeta {
+    def baboonAdtTypeIdentifier: String
+    def baboonAdtType: Class[?]
+  }
+
+  trait BaboonMeta {
+    def sameInVersions(typeId: String): List[String]
+  }
+
+  trait BaboonEnum[T] {
+    def parse(s: String): Option[T]
+    def all: List[T]
+  }
+
+  final class Lazy[T](private val initializer: () => T) {
+    private val valueRef = new AtomicReference[Option[T]](None)
+
+    def value: T = valueRef.get() match {
+      case Some(existing) => existing
+      case None =>
+        val computed = initializer()
+        if (valueRef.compareAndSet(None, Some(computed))) computed
+        else valueRef.get().get
+    }
+
+    def isValueCreated: Boolean = valueRef.get().isDefined
+  }
+
+  object Lazy {
+    def apply[T](initializer: => T): Lazy[T] =
+      new Lazy(() => initializer)
+  }
+
+  trait BaboonSingleton[T] {
+    protected def LazyInstance: Lazy[T]
+    def instance: T = LazyInstance.value
+  }
+
+  final case class BaboonDomainVersion(domainIdentifier: String, domainVersion: String) {
+    private val LazyVersion = Lazy(Version.from(domainVersion))
+    def version: Version    = LazyVersion.value
+  }
+
+  final case class Version(major: Int, minor: Int, patch: Int) extends Ordered[Version] {
+    override def compare(that: Version): Int = Version.ordering.compare(this, that)
+  }
+  object Version {
+    def from(version: String): Version = {
+      val chunks = version.split("\\.")
+      if (chunks.size <= 0) {
+        throw new Exception(s"Expected to have version in format x.[y].[z], got $version");
+      }
+
+      val major = Try(chunks(0).trim.toInt) match {
+        case Success(value) => value
+        case _              => throw new Exception(s"Expected to have version in format x.[y].[z], got $version. Invalid major value.");
+      }
+
+      val minor = Try(chunks(1).trim.toInt) match {
+        case Success(value) => value
+        case _              => throw new Exception(s"Expected to have version in format x.[y].[z], got $version. Invalid minor value.");
+      }
+
+      val patch = Try(chunks(2).trim.toInt) match {
+        case Success(value) => value
+        case _              => throw new Exception(s"Expected to have version in format x.[y].[z], got $version. Invalid patch value.");
+      }
+
+      new Version(major, minor, patch)
+    }
+
+    implicit val ordering: Ordering[Version] = Ordering.by(v => (v.major, v.minor, v.patch))
+  }
+
+  final case class BaboonTypeMeta(
+    metaVersion: Byte,
+    domainIdentifier: String,
+    domainVersion: String,
+    domainVersionMinCompat: String,
+    typeIdentifier: String,
+  ) {
+    def version: BaboonDomainVersion = BaboonDomainVersion(domainIdentifier, domainVersion)
+    def versionMinCompat: Option[BaboonDomainVersion] = {
+      domainVersionMinCompat match {
+        case v if v.isEmpty          => None
+        case v if v == domainVersion => None
+        case _                       => Some(BaboonDomainVersion(domainIdentifier, domainVersionMinCompat))
+      }
+    }
+
+    def writeBin(writer: LEDataOutputStream): Unit = {
+      BaboonTypeMetaCodec.writeBin(this, writer)
+    }
+
+    def writeJson: Json = {
+      BaboonTypeMetaCodec.writeJson(this)
+    }
+  }
+
+  object BaboonTypeMeta {
+    /* Codecs discovery with ADTs check to ensure that ADTs is encoded with a codec type desired by the user.
+     *
+     * - If user is trying to encode ADT branch with the base type we should encode it with ADT meta header:
+     *      `Encode<ADT>(new ADT.A())` -> {"A": {<encoded A>}}
+     * - If user is trying to encode ADT branch with its own type we should encode only branch, without any meta:
+     *      `Encode<ADT.A>(new ADT.A())` -> {<encoded A>}
+     */
+    def from[T <: BaboonGenerated: ClassTag](value: T): BaboonTypeMeta = {
+      val typeIdentifier = value match {
+        case adt: BaboonAdtMemberMeta if typeIsTrait[T] => adt.baboonAdtTypeIdentifier
+        case _                                          => value.baboonTypeIdentifier
+      }
+
+      new BaboonTypeMeta(
+        META_VERSION,
+        value.baboonDomainIdentifier,
+        value.baboonDomainVersion,
+        value.baboonSameInVersions.head,
+        typeIdentifier,
+      )
+    }
+
+    private def typeIsTrait[T](implicit ct: ClassTag[T]): Boolean = {
+      ct.runtimeClass.isInterface
+    }
+
+    def readMeta(reader: LEDataInputStream): Option[BaboonTypeMeta] = {
+      BaboonTypeMetaCodec.readMeta(reader)
+    }
+
+    def readMeta(json: Json): Option[BaboonTypeMeta] = {
+      BaboonTypeMetaCodec.readMeta(json)
+    }
+  }
+
+  object BaboonTypeMetaCodec {
+    private val META_VERSION_1: Byte = 1
+    val META_VERSION: Byte           = META_VERSION_1
+
+    private val META_VERSION_KEY              = "$mv"
+    private val DOMAIN_IDENTIFIER_KEY         = "$d"
+    private val DOMAIN_VERSION_KEY            = "$v"
+    private val DOMAIN_VERSION_MIN_COMPAT_KEY = "$uv"
+    private val TYPE_IDENTIFIER_KEY           = "$t"
+
+    def writeBin(meta: BaboonTypeMeta, writer: LEDataOutputStream): Unit = {
+      writer.write(META_VERSION_1)
+      BaboonBinTools.writeString(writer, meta.domainIdentifier)
+      BaboonBinTools.writeString(writer, meta.domainVersion)
+      if (meta.domainVersion == meta.domainVersionMinCompat) {
+        writer.write(0.toByte)
+      } else {
+        writer.write(1.toByte)
+        BaboonBinTools.writeString(writer, meta.domainVersionMinCompat)
+      }
+      BaboonBinTools.writeString(writer, meta.typeIdentifier)
+    }
+
+    def writeJson(meta: BaboonTypeMeta): Json = {
+      val json = Json.obj(
+        DOMAIN_IDENTIFIER_KEY -> Json.fromString(meta.domainIdentifier),
+        DOMAIN_VERSION_KEY    -> Json.fromString(meta.domainVersion),
+        TYPE_IDENTIFIER_KEY   -> Json.fromString(meta.typeIdentifier),
+      )
+      if (meta.domainVersion != meta.domainVersionMinCompat) {
+        json.mapObject(_.add(DOMAIN_VERSION_MIN_COMPAT_KEY, Json.fromString(meta.domainVersionMinCompat)))
+      } else json
+    }
+
+    def readMeta(reader: LEDataInputStream): Option[BaboonTypeMeta] = {
+      val metaVersion = reader.readByte()
+      if (metaVersion == 1) {
+        readMetaV1(reader)
+      } else None
+    }
+
+    def readMeta(json: Json): Option[BaboonTypeMeta] = {
+      if (!json.isObject) return None
+
+      json.hcursor.downField(META_VERSION_KEY).as[String].toOption match {
+        case Some(value) =>
+          if (value.toByte == META_VERSION_1) readMetaV1(json) else None
+        case None => readMetaV1(json)
+      }
+    }
+
+    private def readMetaV1(reader: LEDataInputStream): Option[BaboonTypeMeta] = {
+      val domainIdentifier       = BaboonBinTools.readString(reader)
+      val domainVersion          = BaboonBinTools.readString(reader)
+      val domainVersionMinCompat = if (reader.readByte() == 1) BaboonBinTools.readString(reader) else domainVersion
+      val typeIdentifier         = BaboonBinTools.readString(reader)
+
+      Some(
+        BaboonTypeMeta(
+          META_VERSION_1,
+          domainIdentifier,
+          domainVersion,
+          domainVersionMinCompat,
+          typeIdentifier,
+        )
+      )
+    }
+
+    private def readMetaV1(json: Json): Option[BaboonTypeMeta] = {
+      val cursor = json.hcursor
+      (for {
+        domainIdentifier <- cursor.downField(DOMAIN_IDENTIFIER_KEY).as[String]
+        domainVersion    <- cursor.downField(DOMAIN_VERSION_KEY).as[String]
+        typeIdentifier   <- cursor.downField(TYPE_IDENTIFIER_KEY).as[String]
+        domainVersionMinCompat <- cursor
+          .downField(DOMAIN_VERSION_MIN_COMPAT_KEY)
+          .focus.fold[Either[DecodingFailure, String]](Right(domainVersion))(_.as[String])
+      } yield BaboonTypeMeta(
+        META_VERSION_1,
+        domainIdentifier,
+        domainVersion,
+        domainVersionMinCompat,
+        typeIdentifier,
+      )).toOption
+    }
+  }
+}
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonTools.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonTools.scala
new file mode 100644
index 00000000..dcaf89f4
--- /dev/null
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonTools.scala
@@ -0,0 +1,311 @@
+package baboon.runtime.shared {
+
+  import java.math.{BigDecimal, BigInteger}
+  import java.nio.charset.StandardCharsets
+  import java.time.format.DateTimeFormatter
+  import java.time.{Instant, OffsetDateTime, ZoneOffset}
+  import java.util.UUID
+
+  object BaboonTimeFormats {
+
+    // Use 3 fractional digits (milliseconds) to match C# DateTime precision
+    // Use XXX (uppercase) to handle both '+00:00' and 'Z' for UTC
+    val tsuFormat: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX")
+    val tsoFormat: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX")
+
+    def parseTso(s: String): Option[OffsetDateTime] = Some(OffsetDateTime.parse(s, tsoFormat))
+    def parseTsu(s: String): Option[OffsetDateTime] = Some(OffsetDateTime.parse(s, tsuFormat))
+
+    def formatTsu(s: OffsetDateTime): String = s.format(tsuFormat)
+    def formatTso(s: OffsetDateTime): String = s.format(tsoFormat)
+
+    def decodeTsuFromBin(s: LEDataInputStream): OffsetDateTime = decodeFromBin(s)
+    def decodeTsoFromBin(s: LEDataInputStream): OffsetDateTime = decodeFromBin(s)
+
+    def decodeFromBin(s: LEDataInputStream): OffsetDateTime = {
+      val millis       = s.readLong()
+      val offsetMillis = s.readLong()
+      val kind         = s.readByte()
+      assert(kind >= 0 && kind <= 2)
+
+      val instant = Instant.ofEpochMilli(millis)
+      val offset  = ZoneOffset.ofTotalSeconds((offsetMillis / 1000).toInt)
+
+      OffsetDateTime.ofInstant(instant, offset)
+    }
+
+    def encodeTsuToBin(dt: OffsetDateTime, writer: LEDataOutputStream): Unit = {
+      encodeToBin(dt, writer, 1)
+    }
+
+    def encodeTsoToBin(dt: OffsetDateTime, writer: LEDataOutputStream): Unit = {
+      encodeToBin(dt, writer, 0)
+    }
+
+    def encodeToBin(dt: OffsetDateTime, writer: LEDataOutputStream, kind: Byte): Unit = {
+      val millis       = dt.toInstant.toEpochMilli
+      val offsetMillis = dt.getOffset.getTotalSeconds * 1000L
+      writer.writeLong(millis)
+      writer.writeLong(offsetMillis)
+      writer.writeByte(kind.toInt)
+    }
+
+  }
+
+  object BaboonBinTools {
+    def toUnsignedBigInt(l: Long): BigInt = {
+      if (l >= 0) {
+        BigInt(l)
+      } else {
+        val upper = (l >>> 32).toInt
+        val lower = l.toInt
+        BigInteger
+          .valueOf(java.lang.Integer.toUnsignedLong(upper))
+          .shiftLeft(32)
+          .add(BigInteger.valueOf(java.lang.Integer.toUnsignedLong(lower)))
+      }
+    }
+
+    def readUid(s: LEDataInputStream): UUID = {
+      // Read 16 bytes in .NET GUID format (mixed-endian)
+      val bytes = new Array[Byte](16)
+      s.readFully(bytes)
+
+      // Convert from .NET GUID byte order to Java UUID byte order
+      // .NET uses little-endian for first 8 bytes (Data1, Data2, Data3),
+      // then big-endian for last 8 bytes (Data4)
+      // We need to reverse the byte order of the first 3 fields
+
+      // Reverse bytes 0-3 (Data1 - 4 bytes)
+      val b0 = bytes(0); bytes(0) = bytes(3); bytes(3) = b0
+      val b1 = bytes(1); bytes(1) = bytes(2); bytes(2) = b1
+
+      // Reverse bytes 4-5 (Data2 - 2 bytes)
+      val b4 = bytes(4); bytes(4) = bytes(5); bytes(5) = b4
+
+      // Reverse bytes 6-7 (Data3 - 2 bytes)
+      val b6 = bytes(6); bytes(6) = bytes(7); bytes(7) = b6
+
+      // Bytes 8-15 (Data4) are already in the correct order (big-endian)
+
+      // Now construct UUID from the corrected big-endian bytes
+      val msb = ((bytes(0) & 0xFFL) << 56) |
+        ((bytes(1) & 0xFFL) << 48) |
+        ((bytes(2) & 0xFFL) << 40) |
+        ((bytes(3) & 0xFFL) << 32) |
+        ((bytes(4) & 0xFFL) << 24) |
+        ((bytes(5) & 0xFFL) << 16) |
+        ((bytes(6) & 0xFFL) << 8) |
+        (bytes(7) & 0xFFL)
+
+      val lsb = ((bytes(8) & 0xFFL) << 56) |
+        ((bytes(9) & 0xFFL) << 48) |
+        ((bytes(10) & 0xFFL) << 40) |
+        ((bytes(11) & 0xFFL) << 32) |
+        ((bytes(12) & 0xFFL) << 24) |
+        ((bytes(13) & 0xFFL) << 16) |
+        ((bytes(14) & 0xFFL) << 8) |
+        (bytes(15) & 0xFFL)
+
+      new UUID(msb, lsb)
+    }
+    def writeUid(fakeWriter: LEDataOutputStream, v: UUID): Unit = {
+      // Convert Java UUID (big-endian) to .NET GUID format (mixed-endian)
+      val msb = v.getMostSignificantBits
+      val lsb = v.getLeastSignificantBits
+
+      // Extract bytes in big-endian order
+      val bytes = new Array[Byte](16)
+      bytes(0)  = ((msb >> 56) & 0xFF).toByte
+      bytes(1)  = ((msb >> 48) & 0xFF).toByte
+      bytes(2)  = ((msb >> 40) & 0xFF).toByte
+      bytes(3)  = ((msb >> 32) & 0xFF).toByte
+      bytes(4)  = ((msb >> 24) & 0xFF).toByte
+      bytes(5)  = ((msb >> 16) & 0xFF).toByte
+      bytes(6)  = ((msb >> 8) & 0xFF).toByte
+      bytes(7)  = (msb & 0xFF).toByte
+      bytes(8)  = ((lsb >> 56) & 0xFF).toByte
+      bytes(9)  = ((lsb >> 48) & 0xFF).toByte
+      bytes(10) = ((lsb >> 40) & 0xFF).toByte
+      bytes(11) = ((lsb >> 32) & 0xFF).toByte
+      bytes(12) = ((lsb >> 24) & 0xFF).toByte
+      bytes(13) = ((lsb >> 16) & 0xFF).toByte
+      bytes(14) = ((lsb >> 8) & 0xFF).toByte
+      bytes(15) = (lsb & 0xFF).toByte
+
+      // Convert to .NET GUID byte order by reversing the first 3 fields
+      // Reverse bytes 0-3 (Data1 - 4 bytes)
+      val b0 = bytes(0); bytes(0) = bytes(3); bytes(3) = b0
+      val b1 = bytes(1); bytes(1) = bytes(2); bytes(2) = b1
+
+      // Reverse bytes 4-5 (Data2 - 2 bytes)
+      val b4 = bytes(4); bytes(4) = bytes(5); bytes(5) = b4
+
+      // Reverse bytes 6-7 (Data3 - 2 bytes)
+      val b6 = bytes(6); bytes(6) = bytes(7); bytes(7) = b6
+
+      // Bytes 8-15 (Data4) stay in big-endian order
+
+      // Write all 16 bytes in .NET GUID format
+      fakeWriter.write(bytes)
+    }
+
+    def readByteString(input: LEDataInputStream): ByteString = {
+      val length = input.readInt()
+      val bytes  = new Array[Byte](length)
+      input.readFully(bytes)
+      ByteString(bytes)
+    }
+
+    def writeByteString(output: LEDataOutputStream, bs: ByteString): Unit = {
+      output.writeInt(bs.length)
+      output.write(bs.underlyingUnsafe)
+    }
+
+    def readString(input: LEDataInputStream): String = {
+      var length   = 0
+      var shift    = 0
+      var byteRead = 0
+
+      do {
+        byteRead = input.readByte() & 0xFF // Read unsigned byte
+        length |= (byteRead & 0x7F) << shift
+        shift += 7
+      } while ((byteRead & 0x80) != 0)
+
+      val buffer = new Array[Byte](length)
+      input.readFully(buffer)
+      new String(buffer, StandardCharsets.UTF_8)
+    }
+
+    def writeString(output: LEDataOutputStream, s: String): Unit = {
+      val bytes = s.getBytes(StandardCharsets.UTF_8)
+      var value = bytes.length
+
+      do {
+        var currentByte = (value & 0x7F).toByte
+        value >>>= 7
+        if (value != 0) currentByte = (currentByte | 0x80).toByte
+        output.writeByte(currentByte.toInt)
+      } while (value != 0)
+
+      output.write(bytes)
+    }
+
+    def readBigDecimal(input: LEDataInputStream): BigDecimal = {
+      val lo    = input.readInt()
+      val mid   = input.readInt()
+      val hi    = input.readInt()
+      val flags = input.readInt()
+
+      val scale      = (flags >> 16) & 0xFF
+      val isNegative = (flags & 0x80000000) != 0
+
+      // Reconstruct 96-bit mantissa - properly mask all values to unsigned
+      val loLong  = lo.toLong & 0xFFFFFFFFL
+      val midLong = mid.toLong & 0xFFFFFFFFL
+      val hiLong  = hi.toLong & 0xFFFFFFFFL
+
+      val mantissa       = (BigInt(hiLong) << 64) | (BigInt(midLong) << 32) | BigInt(loLong)
+      val signedMantissa = if (isNegative) -mantissa else mantissa
+
+      new java.math.BigDecimal(signedMantissa.bigInteger, scale)
+    }
+
+    def writeBigDecimal(output: LEDataOutputStream, value: scala.math.BigDecimal): Unit = {
+      // .NET decimal is 16 bytes: lo (int32), mid (int32), hi (int32), flags (int32)
+      // flags contains: sign bit (bit 31) and scale (bits 16-23)
+      val unscaled = value.bigDecimal.unscaledValue()
+      val scale    = value.scale
+      require(scale >= 0 && scale <= 28, "C# Decimal supports scale 0–28")
+      require(unscaled.bitLength() <= 96, "C# Decimal mantissa must fit in 96 bits")
+
+      // Get the 96-bit unscaled value as 3 x 32-bit integers using bit shifting
+      val absUnscaled = unscaled.abs()
+      val lo          = absUnscaled.intValue()
+      val mid         = absUnscaled.shiftRight(32).intValue()
+      val hi          = absUnscaled.shiftRight(64).intValue()
+
+      // Build flags: sign in bit 31, scale in bits 16-23
+      val sign  = if (unscaled.signum() < 0) 0x80000000 else 0
+      val flags = sign | (scale << 16)
+
+      output.writeInt(lo)
+      output.writeInt(mid)
+      output.writeInt(hi)
+      output.writeInt(flags)
+    }
+
+    def readTimestamp(wire: LEDataInputStream): OffsetDateTime = {
+      // Read timestamp: 8 bytes (local ticks in ms) + 8 bytes (offset in ms) + 1 byte (kind) = 17 bytes
+      // C# writes DateTimeOffset.Ticks which is LOCAL time, not UTC!
+      val b0                 = wire.readByte() & 0xFFL
+      val b1                 = wire.readByte() & 0xFFL
+      val b2                 = wire.readByte() & 0xFFL
+      val b3                 = wire.readByte() & 0xFFL
+      val b4                 = wire.readByte() & 0xFFL
+      val b5                 = wire.readByte() & 0xFFL
+      val b6                 = wire.readByte() & 0xFFL
+      val b7                 = wire.readByte() & 0xFFL
+      val dotNetLocalTicksMs = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24) | (b4 << 32) | (b5 << 40) | (b6 << 48) | (b7 << 56)
+
+      val b8       = wire.readByte() & 0xFFL
+      val b9       = wire.readByte() & 0xFFL
+      val b10      = wire.readByte() & 0xFFL
+      val b11      = wire.readByte() & 0xFFL
+      val b12      = wire.readByte() & 0xFFL
+      val b13      = wire.readByte() & 0xFFL
+      val b14      = wire.readByte() & 0xFFL
+      val b15      = wire.readByte() & 0xFFL
+      val offsetMs = b8 | (b9 << 8) | (b10 << 16) | (b11 << 24) | (b12 << 32) | (b13 << 40) | (b14 << 48) | (b15 << 56)
+
+      @annotation.unused
+      val kind = wire.readByte()
+
+      // Convert local time to UTC by subtracting offset
+      val dotNetUtcTicksMs = dotNetLocalTicksMs - offsetMs
+      // Convert from .NET epoch to Unix epoch
+      val epochMs       = dotNetUtcTicksMs - 62135596800000L
+      val offsetSeconds = (offsetMs / 1000).toInt
+      val offset        = ZoneOffset.ofTotalSeconds(offsetSeconds)
+      val instant       = Instant.ofEpochMilli(epochMs)
+      OffsetDateTime.ofInstant(instant, offset)
+    }
+
+    def writeTimestamp(wref: LEDataOutputStream, ref: OffsetDateTime): Unit = {
+      // Write timestamp: 8 bytes (local ticks in ms) + 8 bytes (offset in ms) + 1 byte (kind) = 17 bytes
+      // C# expects DateTimeOffset.Ticks which is LOCAL time, not UTC!
+      val ts_offsetDt         = ref
+      val ts_epochMs          = ts_offsetDt.toInstant.toEpochMilli
+      val ts_dotNetUtcTicksMs = ts_epochMs + 62135596800000L
+      val ts_offsetMs         = ts_offsetDt.getOffset.getTotalSeconds * 1000L
+      // Convert UTC to local time by adding offset (C# expects local ticks)
+      val ts_dotNetLocalTicksMs = ts_dotNetUtcTicksMs + ts_offsetMs
+      val ts_kind: Byte         = if (ts_offsetDt.getOffset.getTotalSeconds == 0) 1.toByte else 0.toByte
+
+      // Write dotNetLocalTicksMs (8 bytes, little-endian)
+      wref.writeByte((ts_dotNetLocalTicksMs & 0xFF).toInt)
+      wref.writeByte(((ts_dotNetLocalTicksMs >> 8) & 0xFF).toInt)
+      wref.writeByte(((ts_dotNetLocalTicksMs >> 16) & 0xFF).toInt)
+      wref.writeByte(((ts_dotNetLocalTicksMs >> 24) & 0xFF).toInt)
+      wref.writeByte(((ts_dotNetLocalTicksMs >> 32) & 0xFF).toInt)
+      wref.writeByte(((ts_dotNetLocalTicksMs >> 40) & 0xFF).toInt)
+      wref.writeByte(((ts_dotNetLocalTicksMs >> 48) & 0xFF).toInt)
+      wref.writeByte(((ts_dotNetLocalTicksMs >> 56) & 0xFF).toInt)
+
+      // Write offsetMs (8 bytes, little-endian)
+      wref.writeByte((ts_offsetMs & 0xFF).toInt)
+      wref.writeByte(((ts_offsetMs >> 8) & 0xFF).toInt)
+      wref.writeByte(((ts_offsetMs >> 16) & 0xFF).toInt)
+      wref.writeByte(((ts_offsetMs >> 24) & 0xFF).toInt)
+      wref.writeByte(((ts_offsetMs >> 32) & 0xFF).toInt)
+      wref.writeByte(((ts_offsetMs >> 40) & 0xFF).toInt)
+      wref.writeByte(((ts_offsetMs >> 48) & 0xFF).toInt)
+      wref.writeByte(((ts_offsetMs >> 56) & 0xFF).toInt)
+
+      // Write kind (1 byte)
+      wref.writeByte(ts_kind.toInt)
+    }
+  }
+
+}
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/BaboonModule.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/BaboonModule.scala
index 12b180b2..6c0d279f 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/BaboonModule.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/BaboonModule.scala
@@ -87,6 +87,7 @@ class BaboonCommonScModule[F[+_, +_]: Error2: TagKK]() extends ModuleDef {
   makeSubcontext[ScDefnTranslator[F]]
     .localDependencies(List(DIKey[Domain], DIKey[BaboonEvolution]))
     .withSubmodule(new ModuleDef {
+      make[ScDomainTreeTools].from[ScDomainTreeTools.ScDomainTreeToolsImpl]
       make[ScDefnTranslator[F]].from[ScDefnTranslator.ScDefnTranslatorImpl[F]]
       make[ScCodecFixtureTranslator].from[ScCodecFixtureTranslator.ScRandomMethodTranslatorImpl]
       make[ScCodecTestsTranslator].from[ScCodecTestsTranslator.Impl]
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/CompilerOptions.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/CompilerOptions.scala
index 06105558..81176aea 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/CompilerOptions.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/CompilerOptions.scala
@@ -29,6 +29,11 @@ object CompilerTarget {
 final case class ScOptions(
   writeEvolutionDict: Boolean,
   wrappedAdtBranchCodecs: Boolean,
+  enableDeprecatedEncoders: Boolean,
+  generateJsonCodecs: Boolean,
+  generateUebaCodecs: Boolean,
+  generateUebaCodecsByDefault: Boolean,
+  generateJsonCodecsByDefault: Boolean,
 )
 
 final case class CSOptions(
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScBaboonTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScBaboonTranslator.scala
index 0262e58b..fd5bf9d6 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScBaboonTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScBaboonTranslator.scala
@@ -119,44 +119,49 @@ class ScBaboonTranslator[F[+_, +_]: Error2](
           q"""unmodified.put("${tid.toString}", $scList(${version.sameIn.map(_.v.toString).map(s => q"\"$s\"").toList.join(", ")}))"""
       }
 
-    scala.collection.mutable.Map.empty[String, String]
     val metaTree =
       q"""object BaboonMetadata extends $baboonMeta {
          |  private val unmodified = ${scMutMap.fullyQualified}.empty[$scString, $scList[$scString]]
          |  
-         |  ${entries.join("\n").shift(2).trim}
+         |  ${entries.joinN().shift(2).trim}
          |
-         |  def unmodifiedSince(typeIdString: $scString): $scList[$scString] = {
-         |    unmodified(typeIdString);
+         |  def sameInVersions(typeId: String): List[String] = {
+         |      unmodified(typeId)
          |  }
          |}""".stripMargin
 
-    val metaSource = Seq(metaTree).join("\n\n")
-    val meta       = scTreeTools.inNs(pkg.parts.toSeq, metaSource)
+    val meta       = scTreeTools.inNs(pkg.parts.toSeq, metaTree)
     val metaOutput = ScDefnTranslator.Output(s"$basename/BaboonMetadata.scala", meta, pkg, CompilerProduct.Definition)
 
     F.pure(List(metaOutput))
   }
 
   private def sharedFixture(): Out[List[ScDefnTranslator.Output]] = {
-    F.pure(List.empty)
-
+    if (target.output.products.contains(CompilerProduct.FixtureRuntime)) {
+      F.pure(
+        List(
+          ScDefnTranslator.Output(
+            "BaboonFixtureShared.scala",
+            TextTree.text(IzResources.readAsString("baboon-runtime/scala/BaboonFixtureShared.scala").get),
+            ScTypes.baboonFixturePkg,
+            CompilerProduct.FixtureRuntime,
+            doNotModify = true,
+          )
+        )
+      )
+    } else F.pure(Nil)
   }
 
   private def renderTree(o: ScDefnTranslator.Output): String = {
     // TODO: better representation
-    // TODO: omit predef
     val usedTypes = o.tree.values.collect { case t: ScValue.ScType => t }.distinct
+      .filterNot(_.predef)
       .filterNot(_.fq)
       .filterNot(_.pkg == o.pkg)
       .filterNot(t => t.pkg.parts.startsWith(o.pkg.parts))
       .sortBy(_.toString)
 
-//    println((o.path, o.pkg))
-//    println(usedTypes.map(t => (t, t.fq)))
-    val imports = usedTypes.toSeq.map {
-      p => q"import ${p.pkg.parts.mkString(".")}.${p.name}"
-    }.join("\n")
+    val imports = usedTypes.map(p => q"import ${p.pkg.parts.mkString(".")}.${p.name}").joinN()
 
     val full = if (o.doNotModify) {
       o.tree
@@ -164,41 +169,44 @@ class ScBaboonTranslator[F[+_, +_]: Error2](
       Seq(
         Seq(imports),
         Seq(o.tree),
-      ).flatten.join("\n\n")
+      ).flatten.joinNN()
     }
 
     full.mapRender {
-      case t: ScValue.ScTypeName =>
-        t.name
-
+      case t: ScValue.ScTypeName => t.name
       case t: ScValue.ScType if !t.fq =>
         if (o.pkg == t.pkg || !t.pkg.parts.startsWith(o.pkg.parts)) {
           t.name
         } else {
           (t.pkg.parts :+ t.name).mkString(".")
         }
-
-      case t: ScValue.ScType =>
-        (t.pkg.parts :+ t.name).mkString(".")
+      case t: ScValue.ScType => (t.pkg.parts :+ t.name).mkString(".")
     }
   }
 
   private def sharedRuntime(): Out[List[scl.ScDefnTranslator.Output]] = {
-    if (target.output.products.contains(CompilerProduct.Runtime)) {
-
-      val sharedOutput = ScDefnTranslator.Output(
-        s"BaboonRuntimeShared.scala",
-        TextTree.text(
-          IzResources
-            .readAsString("baboon-runtime/scala/BaboonRuntimeShared.scala").get
-            // TODO: fixed in izumi, hack, we always force escape processing in text tree
-            .replace("""[\\s:-]""", """[\\\\s:-]""")
-        ),
+    def rt(path: String, resource: String, preprocessResource: String => String = identity): ScDefnTranslator.Output = {
+      ScDefnTranslator.Output(
+        path,
+        TextTree.text(IzResources.readAsString(resource).map(preprocessResource).get),
         ScTypes.baboonRuntimePkg,
         CompilerProduct.Runtime,
         doNotModify = true,
       )
-      F.pure(List(sharedOutput))
+    }
+    // TODO: fix in izumi, hack, we always force escape processing in text tree
+    if (target.output.products.contains(CompilerProduct.Runtime)) {
+      F.pure(
+        List(
+          rt("BaboonByteString.scala", "baboon-runtime/scala/BaboonByteString.scala", _.replace("""[\\s:-]""", """[\\\\s:-]""")),
+          rt("BaboonCodecs.scala", "baboon-runtime/scala/BaboonCodecs.scala"),
+          rt("BaboonCodecsFacade.scala", "baboon-runtime/scala/BaboonCodecsFacade.scala"),
+          rt("BaboonConversions.scala", "baboon-runtime/scala/BaboonConversions.scala"),
+          rt("BaboonExceptions.scala", "baboon-runtime/scala/BaboonExceptions.scala"),
+          rt("BaboonRuntimeShared.scala", "baboon-runtime/scala/BaboonRuntimeShared.scala", _.replace("""\\.""", """\\\\.""")),
+          rt("BaboonTools.scala", "baboon-runtime/scala/BaboonTools.scala"),
+        )
+      )
     } else {
       F.pure(List.empty)
     }
@@ -234,26 +242,29 @@ class ScBaboonTranslator[F[+_, +_]: Error2](
 
       val converter =
         q"""trait RequiredConversions {
-           |    ${missing.join("\n").shift(4).trim}
+           |    ${missing.joinN().shift(4).trim}
            |}
            |
-           |class BaboonConversions(required: RequiredConversions) extends $abstractBaboonConversions {
-           |    ${conversionRegs.join("\n").shift(4).trim}
+           |class BaboonConversions(required: RequiredConversions) extends $baboonAbstractConversions {
+           |    ${conversionRegs.joinN().shift(4).trim}
            |
            |    override def versionsFrom: $scList[$scString] = $scList(${toCurrent.map(_.from.v.toString).map(v => s"\"$v\"").mkString(", ")})
            |    override def versionTo: $scString = "${domain.version.v.toString}"
            |}""".stripMargin
 
-      // Scala codecs definitions (stub syntax)
-      val codecs =
-        q"""object BaboonCodecs extends $abstractBaboonCodecs {
-           |    // register codecs
-           |    ${defnOut.flatMap(_.codecReg).join("\n").shift(4).trim}
-           |}""".stripMargin
+      import izumi.fundamentals.collections.IzCollections.*
+      val regsMap = defnOut.flatMap(_.codecReg).toMultimap.view.mapValues(_.flatten).toMap
+
+      val codecs = regsMap.map {
+        case (codecId, regs) =>
+          q"""object BaboonCodecs${codecId.capitalize} extends ${abstractBaboonCodec(codecId)}{
+             |  ${regs.toList.map(c => q"register($c)").joinN().shift(2).trim}
+             |}""".stripMargin
+      }.toList.joinNN()
 
       val basename = scFiles.basename(domain, lineage.evolution)
 
-      val runtimeSource = Seq(converter, codecs).join("\n\n")
+      val runtimeSource = Seq(converter, codecs).joinNN()
       val runtime       = scTreeTools.inNs(pkg.parts.toSeq, runtimeSource)
       val runtimeOutput = ScDefnTranslator.Output(
         s"$basename/BaboonRuntime.scala",
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecFixtureTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecFixtureTranslator.scala
index 3e7b1621..144a3dc0 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecFixtureTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecFixtureTranslator.scala
@@ -28,17 +28,12 @@ object ScCodecFixtureTranslator {
       definition.defn match {
         case _ if enquiries.hasForeignType(definition, domain)     => None
         case _ if enquiries.isRecursiveTypedef(definition, domain) => None
-
-        case dto: Typedef.Dto =>
-          Some(doTranslateDto(dto))
-
-        case adt: Typedef.Adt =>
-          Some(doTranslateAdt(adt))
-
-        case _: Typedef.Contract => None
-        case _: Typedef.Enum     => None
-        case _: Typedef.Foreign  => None
-        case _: Typedef.Service  => None
+        case dto: Typedef.Dto                                      => Some(doTranslateDto(dto))
+        case adt: Typedef.Adt                                      => Some(doTranslateAdt(adt))
+        case _: Typedef.Contract                                   => None
+        case _: Typedef.Enum                                       => None
+        case _: Typedef.Foreign                                    => None
+        case _: Typedef.Service                                    => None
       }
     }
 
@@ -71,12 +66,8 @@ object ScCodecFixtureTranslator {
             case _: Typedef.Enum                              => None
             case _: Typedef.Foreign                           => None
             case _: Typedef.Service                           => None
-
-            case dto: Typedef.Dto =>
-              Some(fixtureTpe(dto.id))
-
-            case adt: Typedef.Adt =>
-              Some(fixtureTpe(adt.id))
+            case dto: Typedef.Dto                             => Some(fixtureTpe(dto.id))
+            case adt: Typedef.Adt                             => Some(fixtureTpe(adt.id))
           }
       }
 
@@ -90,7 +81,7 @@ object ScCodecFixtureTranslator {
       val generatedFields = dto.fields.map(f => genType(f.tpe))
       val fullType        = translator.toScTypeRefKeepForeigns(dto.id, domain, evo)
 
-      q"""object ${fixtureTpe(dto.id)} extends $baboonFixture[$fullType] {
+      q"""object ${fixtureTpe(dto.id)} {
          |  def random(rnd: $baboonRandom): $fullType =
          |    $fullType(
          |      ${generatedFields.join(",\n").shift(6).trim}
@@ -104,23 +95,10 @@ object ScCodecFixtureTranslator {
         .flatMap(m => domain.defs.meta.nodes.get(m))
         .collect { case DomainMember.User(_, d: Typedef.Dto, _, _) => d }
 
-      val membersFixtures =
-        members.sortBy(_.id.toString).map(dto => doTranslateDto(dto))
-
-      val membersGenerators = members.sortBy(_.id.toString).map[TextTree[ScValue]] {
-        dto =>
-          val memberFixture =
-            q"${dto.id.name.name}"
-
-          q"${memberFixture}_Fixture.random"
-      }
-
-//      val membersBranches = membersGenerators.zipWithIndex.map {
-//        case (generator, idx) =>
-//          q"""case ${idx.toString} => $generator""".stripMargin
-//      }
+      val membersFixtures   = members.sortBy(_.id.toString).map(dto => doTranslateDto(dto))
+      val membersGenerators = members.sortBy(_.id.toString).map(dto => q"${dto.id.name.name}_Fixture.random")
 
-      q"""object ${fixtureTpe(adt.id)} extends $baboonAdtFixture[${adt.id.name.name}] {
+      q"""object ${fixtureTpe(adt.id)} {
          |  def random(rnd: $baboonRandom): ${adt.id.name.name} = {
          |    rnd.oneOf($scList(
          |      ${membersGenerators.join(",\n").shift(6).trim}
@@ -133,7 +111,7 @@ object ScCodecFixtureTranslator {
          |    )
          |  }
          |  
-         |  ${membersFixtures.join("\n").shift(2).trim}
+         |  ${membersFixtures.joinN().shift(2).trim}
          |}
          |""".stripMargin
     }
@@ -144,20 +122,11 @@ object ScCodecFixtureTranslator {
           case tpe: TypeRef.Scalar => genScalar(tpe)
           case TypeRef.Constructor(id, args) =>
             id match {
-              case Builtins.lst =>
-                q"""rnd.mkList(${gen(args.head)})"""
-
-              case Builtins.set =>
-                q"""rnd.mkSet(${gen(args.head)})"""
-
-              case Builtins.map =>
-                q"""rnd.mkMap(${gen(args(0))}, ${gen(args(1))})"""
-
-              case Builtins.opt =>
-                q"""rnd.mkOption(${gen(args.head)})"""
-
-              case t =>
-                throw new IllegalArgumentException(s"Unexpected collection type: $t")
+              case Builtins.lst => q"rnd.mkList(${gen(args.head)})"
+              case Builtins.set => q"rnd.mkSet(${gen(args.head)})"
+              case Builtins.map => q"rnd.mkMap(${gen(args(0))}, ${gen(args(1))})"
+              case Builtins.opt => q"rnd.mkOption(${gen(args.head)})"
+              case t            => throw new IllegalArgumentException(s"Unexpected collection type: $t")
             }
         }
       }
@@ -166,7 +135,6 @@ object ScCodecFixtureTranslator {
     }
 
     private def genScalar(tpe: TypeRef.Scalar): TextTree[ScValue] = {
-
       tpe.id match {
         case TypeId.Builtins.i08 => q"rnd.nextI08()"
         case TypeId.Builtins.i16 => q"rnd.nextI16()"
@@ -194,11 +162,8 @@ object ScCodecFixtureTranslator {
         case TypeId.User(_, _, name) if enquiries.isEnum(tpe, domain) => q"rnd.mkEnum(${name.name})"
         case u: TypeId.User                                           => q"${u.name.name}_Fixture.random(rnd)"
 
-        case t =>
-          throw new IllegalArgumentException(s"Unexpected scalar type: $t")
+        case t => throw new IllegalArgumentException(s"Unexpected scalar type: $t")
       }
     }
-
   }
-
 }
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala
index 10e7b189..118dc57b 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala
@@ -50,7 +50,7 @@ object ScCodecTestsTranslator {
 
     private def makeTest(definition: DomainMember.User, srcRef: ScValue.ScType): TextTree[ScValue] = {
       val fixture = makeFixture(definition, domain, evo)
-      codecs.map {
+      codecs.filter(_.isActive(definition.id)).map {
         case jsonCodec: ScJsonCodecGenerator =>
           val body      = jsonCodecAssertions(definition)
           val codecName = jsonCodec.codecName(srcRef)
@@ -88,9 +88,7 @@ object ScCodecTestsTranslator {
              |  val csJson = parse(new $scString(b, $javaNioStandardCharsets.UTF_8)).toOption.get
              |  val dec = $codecName.instance.decode(context, csJson).toOption
              |  assert(dec.nonEmpty)
-             |  val sclJson = jsonCompare(context, dec.get, clue)
-             |  // this is be broken for unordered collections and timestamps, but is suitable for manual tests
-             |  //assert(csJson == sclJson)
+             |  jsonCompare(context, dec.get, clue)
              |}
              |"""
 
@@ -125,8 +123,6 @@ object ScCodecTestsTranslator {
              |  val dec = $codecName.instance.decode(context, dis)
              |  val sclUebaBytes = uebaCompare(context, dec, clue)
              |  assert(csUebaBytes.length == sclUebaBytes.length, s"$$clue")
-             |  // this is be broken for unordered collections and timestamps, but is suitable for manual tests
-             |  // assert(csUebaBytes.toVector == sclUebaBytes.toVector) 
              |}
              |
              |def uebaCompare(context: $baboonCodecContext, fixture: $srcRef, clue: $scString): $scArray[$scByte] = {
@@ -148,7 +144,7 @@ object ScCodecTestsTranslator {
         case unknown =>
           logger.message(s"Cannot create codec tests (${unknown.codecName(srcRef)}) for unsupported type $srcRef")
           q""
-      }.toList.map(_.stripMargin.trim).join("\n\n").shift(2).trim
+      }.toList.map(_.stripMargin.trim).joinNN().shift(2).trim
     }
 
     private def makeFixture(
@@ -171,8 +167,7 @@ object ScCodecTestsTranslator {
              |    jsonCompare(context, fixture, clue)
              |}
              |""".stripMargin.trim
-        case _ =>
-          q"jsonCompare(context, fixture, clue)"
+        case _ => q"jsonCompare(context, fixture, clue)"
       }
     }
 
@@ -184,8 +179,7 @@ object ScCodecTestsTranslator {
              |    uebaCompare(context, fixture, clue)
              |}
              |""".stripMargin.trim
-        case _ =>
-          q"uebaCompare(context, fixture, clue)"
+        case _ => q"uebaCompare(context, fixture, clue)"
       }
     }
   }
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTranslator.scala
index 7364fe18..e2ce0ea7 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTranslator.scala
@@ -1,15 +1,15 @@
 package io.septimalmind.baboon.translator.scl
 
 import io.septimalmind.baboon.translator.scl.ScCodecTranslator.CodecMeta
-import io.septimalmind.baboon.typer.model.DomainMember
+import io.septimalmind.baboon.typer.model.{DomainMember, TypeId}
 import izumi.fundamentals.platform.strings.TextTree
 
 trait ScCodecTranslator {
   def translate(defn: DomainMember.User, csRef: ScValue.ScType, srcRef: ScValue.ScType): Option[TextTree[ScValue]]
-
   def codecName(name: ScValue.ScType): ScValue.ScType
-
-  def codecMeta(defn: DomainMember.User, name: ScValue.ScType): CodecMeta
+  def codecMeta(defn: DomainMember.User, name: ScValue.ScType): Option[CodecMeta]
+  def isActive(id: TypeId): Boolean
+  def id: String
 }
 
 object ScCodecTranslator {
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScConversionTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScConversionTranslator.scala
index de5c47c0..90c32f03 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScConversionTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScConversionTranslator.scala
@@ -67,7 +67,12 @@ class ScConversionTranslator[F[+_, +_]: Error2](
     }
   }
 
-  private def transferConstructor(oldRef: TextTree[ScValue], depth: Int, cn: TypeRef.Constructor, co: TypeRef.Constructor) = {
+  private def transferConstructor(
+    oldRef: TextTree[ScValue],
+    depth: Int,
+    cn: TypeRef.Constructor,
+    co: TypeRef.Constructor,
+  ): TextTree[ScValue] = {
     val tmp = q"e${depth.toString}"
     cn match {
       case c: TypeRef.Constructor if c.id == TypeId.Builtins.lst =>
@@ -89,7 +94,13 @@ class ScConversionTranslator[F[+_, +_]: Error2](
     }
   }
 
-  private def transferScalar(oldRef: TextTree[ScValue], newTypeRefTree: TextTree[ScValue], oldTypeRefTree: TextTree[ScValue], s: TypeRef.Scalar, os: TypeRef.Scalar) = {
+  private def transferScalar(
+    oldRef: TextTree[ScValue],
+    newTypeRefTree: TextTree[ScValue],
+    oldTypeRefTree: TextTree[ScValue],
+    s: TypeRef.Scalar,
+    os: TypeRef.Scalar,
+  ): TextTree[ScValue] = {
     val direct = if (s == os) {
       oldRef
     } else {
@@ -131,17 +142,17 @@ class ScConversionTranslator[F[+_, +_]: Error2](
         def tout = trans.asScType(conv.sourceTpe, domain, evo)
 
         val meta = q"""override def versionFrom: String = "${srcVer.v.toString}"
-                      |override def versionTo:   String = "${domain.version.v.toString}"
-                      |override def typeId:      String = "${conv.sourceTpe.toString}"
+                      |override def versionTo: String = "${domain.version.v.toString}"
+                      |override def typeId: String = "${conv.sourceTpe.toString}"
                       """.stripMargin.trim
 
         val rendered = conv match {
           case _: Conversion.CustomConversionRequired =>
             val classDef = q"""|abstract class $className
-                               |  extends $abstractBaboonConversion[$tin, $tout] {
+                               |  extends $baboonAbstractConversion[$tin, $tout] {
                                |    def doConvert[C](
-                               |      context: C,
-                               |      conversions: $abstractBaboonConversions,
+                               |      context: Option[C],
+                               |      conversions: $baboonAbstractConversions,
                                |      from: $tin
                                |    ): $tout
                                |    ${meta.shift(4).trim}
@@ -155,7 +166,7 @@ class ScConversionTranslator[F[+_, +_]: Error2](
                 fname,
                 tools.inNs(pkg.parts.toSeq, classDef),
                 Some(q"register(required.$convMethodName())"),
-                Some(q"def $convMethodName(): $abstractBaboonConversion[$tin, $tout]"),
+                Some(q"def $convMethodName(): $baboonAbstractConversion[$tin, $tout]"),
               )
             )
 
@@ -166,10 +177,10 @@ class ScConversionTranslator[F[+_, +_]: Error2](
 
           case _: Conversion.CopyEnumByName =>
             val classDef = q"""|object $className
-                               |  extends $abstractBaboonConversion[$tin, $tout] {
+                               |  extends $baboonAbstractConversion[$tin, $tout] {
                                |    override def doConvert[C](
-                               |      context: C,
-                               |      conversions: $abstractBaboonConversions,
+                               |      context: Option[C],
+                               |      conversions: $baboonAbstractConversions,
                                |      from: $tin
                                |    ): $tout = $tout.parse(from.toString).get
                                |    ${meta.shift(4).trim}
@@ -187,13 +198,13 @@ class ScConversionTranslator[F[+_, +_]: Error2](
 
             val classDef = q"""
                               |object $className
-                              |  extends $abstractBaboonConversion[$tin, $tout] {
+                              |  extends $baboonAbstractConversion[$tin, $tout] {
                               |    override def doConvert[C](
-                              |      context: C,
-                              |      conversions: $abstractBaboonConversions,
+                              |      context: Option[C],
+                              |      conversions: $baboonAbstractConversions,
                               |      from: $tin
                               |    ): $tout = from match {
-                              |      ${cases.join("\n").shift(6).trim}
+                              |      ${cases.joinN().shift(6).trim}
                               |    }
                               |    ${meta.shift(4).trim}
                               |}
@@ -239,13 +250,13 @@ class ScConversionTranslator[F[+_, +_]: Error2](
             val ctorArgs = dto.fields.map(f => q"${f.name.name.toLowerCase}")
             val classDef = q"""
                               |object $className
-                              |  extends $abstractBaboonConversion[$tin, $tout] {
+                              |  extends $baboonAbstractConversion[$tin, $tout] {
                               |    override def doConvert[C](
-                              |      context: C,
-                              |      conversions: $abstractBaboonConversions,
+                              |      context: Option[C],
+                              |      conversions: $baboonAbstractConversions,
                               |      _from: $tin
                               |    ): $tout = {
-                              |      ${assigns.join("\n").shift(6).trim}
+                              |      ${assigns.joinN().shift(6).trim}
                               |      $tout(
                               |              ${ctorArgs.join(",\n").shift(14).trim}
                               |           )
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDefnTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDefnTranslator.scala
index af1e6355..6635d789 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDefnTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDefnTranslator.scala
@@ -16,13 +16,26 @@ trait ScDefnTranslator[F[+_, +_]] {
 }
 
 object ScDefnTranslator {
-  case class Output(
+  final case class CodecReg(
+    typeId: TypeId,
+    tpe: ScType,
+    tpeKeepForeigns: ScType,
+    tpeId: TextTree[ScValue],
+    trees: Map[String, TextTree[ScValue]],
+  )
+
+  final case class DefnRepr(
+    defn: TextTree[ScValue],
+    codecs: List[CodecReg],
+  )
+
+  final case class Output(
     path: String,
     tree: TextTree[ScValue],
     pkg: ScValue.ScPackageId,
     product: CompilerProduct,
-    doNotModify: Boolean                = false,
-    codecReg: Option[TextTree[ScValue]] = None,
+    doNotModify: Boolean                              = false,
+    codecReg: List[(String, List[TextTree[ScValue]])] = Nil,
   )
 
   class ScDefnTranslatorImpl[F[+_, +_]: Applicative2](
@@ -34,6 +47,7 @@ object ScDefnTranslator {
     codecs: Set[ScCodecTranslator],
     codecTests: ScCodecTestsTranslator,
     codecsFixture: ScCodecFixtureTranslator,
+    scDomainTreeTools: ScDomainTreeTools,
   ) extends ScDefnTranslator[F] {
     import ScTypes.*
 
@@ -45,15 +59,15 @@ object ScDefnTranslator {
     }
 
     private def doTranslate(defn: DomainMember.User): F[NEList[BaboonIssue], List[Output]] = {
-      val (content, reg) = makeFullRepr(defn, inNs = true)
+      val repr = makeFullRepr(defn, inNs = true)
 
-      val registrations = Option(reg.map { case (_, reg) => q"register(new $baboonTypeCodecs($reg))" }).filterNot(_.isEmpty).map(_.join("\n"))
+      val registrations = codecs.toList.map(codec => codec.id -> repr.codecs.flatMap(reg => reg.trees.get(codec.id).map(expr => q"${reg.tpeId}, $expr")))
 
       F.pure(
         List(
           Output(
             getOutputPath(defn),
-            content,
+            repr.defn,
             trans.toScPkg(domain.id, domain.version, evo),
             CompilerProduct.Definition,
             codecReg = registrations,
@@ -126,7 +140,7 @@ object ScDefnTranslator {
     private def makeFullRepr(
       defn: DomainMember.User,
       inNs: Boolean,
-    ): (TextTree[ScValue], List[(ScType, TextTree[ScValue])]) = {
+    ): DefnRepr = {
       val isLatestVersion = domain.version == evo.latest
 
       def obsoletePrevious(tree: TextTree[ScValue]): TextTree[ScValue] = {
@@ -138,53 +152,53 @@ object ScDefnTranslator {
         }
       }
 
-      val csTypeRef = trans.asScType(defn.id, domain, evo)
+      val scTypeRef = trans.asScType(defn.id, domain, evo)
       val srcRef    = trans.toScTypeRefKeepForeigns(defn.id, domain, evo)
 
-      val (defnReprBase, extraRegs) =
-        makeRepr(defn, csTypeRef, isLatestVersion)
+      val repr = makeRepr(defn, scTypeRef, isLatestVersion)
 
       val codecTrees =
         codecs.toList
-          .flatMap(t => t.translate(defn, csTypeRef, srcRef).toList)
+          .flatMap(t => t.translate(defn, scTypeRef, srcRef).toList)
           .map(obsoletePrevious)
 
-      val defnRepr = obsoletePrevious(defnReprBase)
+      val defnRepr = obsoletePrevious(repr.defn)
 
       assert(defn.id.pkg == domain.id)
 
       val ns = srcRef.pkg.parts
 
-      val allDefs = (defnRepr +: codecTrees).join("\n\n")
+      val allDefs = (defnRepr +: codecTrees).joinNN()
       val content = if (inNs) scTrees.inNs(ns.toSeq, allDefs) else allDefs
 
       val reg = defn.defn match {
-        case _: Typedef.NonDataTypedef =>
-          List.empty[(ScType, TextTree[ScValue])]
-        case _ =>
+        case _: Typedef.NonDataTypedef => Nil
+        case d =>
           val codecsReg = codecs.toList
             .sortBy(_.getClass.getName)
-            .map(codec => q"${codec.codecName(srcRef).copy(fq = true)}")
-          val reg =
-            (List(q"""\"${defn.id.toString}\"""") ++ codecsReg).join(", ")
-          List(csTypeRef -> reg)
+            .flatMap(
+              codec =>
+                if (codec.isActive(d.id)) List(codec.id -> q"$baboonLazy(${codec.codecName(srcRef).copy(fq = true)})")
+                else Nil
+            )
+          List(CodecReg(defn.id, scTypeRef, srcRef, q"\"${defn.id.toString}\"", codecsReg.toMap))
       }
 
-      val allRegs = reg ++ extraRegs
+      val allRegs = reg ++ repr.codecs
 
-      (content, allRegs)
+      DefnRepr(content, allRegs)
     }
 
-    private def makeRepr(defn: DomainMember.User, name: ScValue.ScType, isLatestVersion: Boolean): (TextTree[ScValue], List[(ScType, TextTree[ScValue])]) = {
+    private def makeRepr(
+      defn: DomainMember.User,
+      name: ScValue.ScType,
+      isLatestVersion: Boolean,
+    ): DefnRepr = {
       val genMarker = if (isLatestVersion) iBaboonGeneratedLatest else iBaboonGenerated
-      val mainMeta  = List.empty[TextTree[ScValue]] // csDomTrees.makeMeta(defn, isCodec = false)
-      val codecMeta = codecs.map(_.codecMeta(defn, name).member)
-      // TODO:
-      val meta = mainMeta ++ codecMeta
-
-      val fixtureRef = codecsFixture.fixtureTpe(defn).map(id => q"implicit def fixture: $baboonFixture[${name.asName}] = $id").getOrElse(q"")
+      val mainMeta  = scDomainTreeTools.makeDataMeta(defn)
+      val codecMeta = codecs.flatMap(_.codecMeta(defn, name).map(_.member))
 
-      val tree: TextTree[ScValue] = defn.defn match {
+      defn.defn match {
         case dto: Typedef.Dto =>
           val params = dto.fields.map {
             f =>
@@ -200,13 +214,21 @@ object ScDefnTranslator {
           val parents          = adtParents ++ contractParents :+ genMarker
           val extendsClauseDto = if (parents.nonEmpty) q" extends ${parents.map(t => q"$t").join(" with ")}" else q""
 
-          q"""final case class ${name.asName}(
-             |  ${paramsList.shift(2).trim}
-             |)$extendsClauseDto
-             |
-             |object ${name.asName} {
-             |  $fixtureRef
-             |}""".stripMargin
+          val objectMetaFields = mainMeta.map(_.valueField) ++ codecMeta
+          val classMetaFields  = mainMeta.map(mt => q"override ${mt.refValueField}")
+
+          DefnRepr(
+            q"""final case class ${name.asName}(
+               |  ${paramsList.shift(2).trim}
+               |)$extendsClauseDto {
+               |  ${classMetaFields.joinN().shift(2).trim}
+               |}
+               |
+               |object ${name.asName} {
+               |  ${objectMetaFields.joinN().shift(2).trim}
+               |}""".stripMargin,
+            Nil,
+          )
 
         case e: Typedef.Enum =>
           val traitTree = q"sealed trait ${name.asName}"
@@ -229,23 +251,22 @@ object ScDefnTranslator {
               q"$obj"
           }.toList
 
-          val companion = q"""object ${name.asName} extends $baboonEnum[${name.asName}] {
-                             |  ${cases.join("\n").shift(2).trim}
-                             |  
-                             |  $fixtureRef
-                             |
-                             |  def parse(s: $scString): $scOption[${name.asName}] = {
-                             |    s match {
-                             |      ${parseCases.join("\n").shift(6).trim}
-                             |      case _ => None
-                             |    }
-                             |  }
-                             |  
-                             |  def all: $scList[${name.asName}] = $scList(
-                             |    ${names.join(",\n").shift(4).trim}
-                             |  ) 
-                             |}""".stripMargin
-          Seq(traitTree, companion).join("\n\n")
+          val companion =
+            q"""object ${name.asName} extends $baboonEnum[${name.asName}] {
+               |  ${cases.joinN().shift(2).trim}
+               |  
+               |  def parse(s: $scString): $scOption[${name.asName}] = {
+               |    s match {
+               |      ${parseCases.joinN().shift(6).trim}
+               |      case _ => None
+               |    }
+               |  }
+               |  
+               |  def all: $scList[${name.asName}] = $scList(
+               |    ${names.join(",\n").shift(4).trim}
+               |  ) 
+               |}""".stripMargin
+          DefnRepr(Seq(traitTree, companion).joinNN(), Nil)
 
         case adt: Typedef.Adt =>
           val parents          = adt.contracts.map(c => trans.toScTypeRefKeepForeigns(c, domain, evo)) :+ genMarker
@@ -259,17 +280,20 @@ object ScDefnTranslator {
               }
           }
 
-          val adtFixtureRef = codecsFixture.fixtureTpe(defn).map(id => q"implicit def fixture: $baboonAdtFixture[${name.asName}] = $id").getOrElse(q"")
+          val objectMetaFields = mainMeta.map(_.valueField) ++ codecMeta
+          val classMetaFields  = mainMeta.map(mt => q"override ${mt.refValueField}")
 
-          val fullTree =
-            q"""$sealedTrait
+          DefnRepr(
+            q"""$sealedTrait {
+               |  ${classMetaFields.joinN().shift(2).trim}
+               |}
                |
                |object ${name.asName} {
-               |  ${memberTrees.map(_._1).toList.join("\n\n").shift(2).trim}
-               |  $adtFixtureRef
-               |}""".stripMargin
-//          val regs = memberTrees.flatMap(_._2)
-          fullTree
+               |  ${memberTrees.map(_.defn).toList.joinNN().shift(2).trim}
+               |  ${objectMetaFields.joinN().shift(2).trim}
+               |}""".stripMargin,
+            Nil,
+          )
 
         case contract: Typedef.Contract =>
           val methods = contract.fields.map {
@@ -279,10 +303,13 @@ object ScDefnTranslator {
           }
           val parents       = contract.contracts.map(c => trans.toScTypeRefKeepForeigns(c, domain, evo)) :+ genMarker
           val extendsClause = if (parents.nonEmpty) q" extends ${parents.map(t => q"$t").join(" with ")}" else q""
-          val body          = if (methods.nonEmpty) methods.join("\n") else q""
-          q"""trait ${name.asName}$extendsClause {
-             |    ${body.shift(4).trim}
-             |}""".stripMargin
+          val body          = if (methods.nonEmpty) methods.joinN() else q""
+          DefnRepr(
+            q"""trait ${name.asName}$extendsClause {
+               |    ${body.shift(4).trim}
+               |}""".stripMargin,
+            Nil,
+          )
 
         case service: Typedef.Service =>
           val methods = service.methods.map {
@@ -298,15 +325,17 @@ object ScDefnTranslator {
               }
               q"def ${m.name.name}(arg: $in): $ret"
           }
-          val body = if (methods.nonEmpty) methods.join("\n") else q""
-          q"""trait ${name.asName} {
-             |    ${body.shift(4).trim}
-             |}""".stripMargin
+          val body = if (methods.nonEmpty) methods.joinN() else q""
+          DefnRepr(
+            q"""trait ${name.asName} {
+               |    ${body.shift(4).trim}
+               |}""".stripMargin,
+            Nil,
+          )
+
+        case _: Typedef.Foreign => DefnRepr(q"", Nil)
 
-        case _: Typedef.Foreign =>
-          q""
       }
-      (tree, List.empty)
     }
 
     private def getOutputPath(defn: DomainMember.User, suffix: Option[String] = None): String = {
@@ -320,5 +349,4 @@ object ScDefnTranslator {
       }
     }
   }
-
 }
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDomainTreeTools.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDomainTreeTools.scala
new file mode 100644
index 00000000..c190753d
--- /dev/null
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDomainTreeTools.scala
@@ -0,0 +1,87 @@
+package io.septimalmind.baboon.translator.scl
+
+import io.septimalmind.baboon.translator.scl.ScDomainTreeTools.MetaField
+import io.septimalmind.baboon.translator.scl.ScTypes.{javaClass, scList, scString}
+import io.septimalmind.baboon.typer.model.*
+import izumi.fundamentals.platform.strings.TextTree
+import izumi.fundamentals.platform.strings.TextTree.Quote
+
+trait ScDomainTreeTools {
+  def makeDataMeta(defn: DomainMember.User): List[MetaField]
+  def makeCodecMeta(defn: DomainMember.User): List[MetaField]
+}
+
+object ScDomainTreeTools {
+  final case class MetaField(
+    signature: TextTree[ScValue],
+    value: TextTree[ScValue],
+    refValue: TextTree[ScValue],
+  ) {
+    def valueField: TextTree[ScValue]    = q"$signature = $value"
+    def refValueField: TextTree[ScValue] = q"$signature = $refValue"
+  }
+
+  final class ScDomainTreeToolsImpl(
+    domain: Domain,
+    evolution: BaboonEvolution,
+    typeTranslator: ScTypeTranslator,
+  ) extends ScDomainTreeTools {
+    override def makeDataMeta(defn: DomainMember.User): List[MetaField] = {
+      mainMeta(defn) ++ sameInVersion(defn) ++ adtMeta(defn)
+    }
+
+    override def makeCodecMeta(defn: DomainMember.User): List[MetaField] = {
+      mainMeta(defn) ++ adtMeta(defn)
+    }
+
+    private def mainMeta(defn: DomainMember.User): List[MetaField] = {
+      val ref = typeTranslator.asScType(defn.id, domain, evolution).fullyQualified
+      val baboonDomainVersion = MetaField(
+        q"def baboonDomainVersion: $scString",
+        q"\"${domain.version.v.toString}\"",
+        q"$ref.baboonDomainVersion",
+      )
+      val baboonDomainIdentifier = MetaField(
+        q"def baboonDomainIdentifier: $scString",
+        q"\"${defn.id.pkg.toString}\"",
+        q"$ref.baboonDomainIdentifier",
+      )
+      val baboonTypeIdentifier = MetaField(
+        q"def baboonTypeIdentifier: $scString",
+        q"\"${defn.id.toString}\"",
+        q"$ref.baboonTypeIdentifier",
+      )
+      List(baboonDomainVersion, baboonDomainIdentifier, baboonTypeIdentifier)
+    }
+
+    private def adtMeta(defn: DomainMember.User): List[MetaField] = {
+      defn.id.owner match {
+        case Owner.Adt(id) =>
+          val adtRef = typeTranslator.asScType(defn.id, domain, evolution).fullyQualified
+          val adtTypeIdentifier = MetaField(
+            q"def baboonAdtTypeIdentifier: $scString",
+            q"\"${id.toString}\"",
+            q"$adtRef.baboonAdtTypeIdentifier",
+          )
+          val baboonAdtType = MetaField(
+            q"def baboonAdtType: $javaClass[?]",
+            q"${typeTranslator.asScType(id, domain, evolution)}.getClass",
+            q"$adtRef.baboonAdtType",
+          )
+          List(adtTypeIdentifier, baboonAdtType)
+        case _ => Nil
+      }
+    }
+
+    private def sameInVersion(defn: DomainMember.User): List[MetaField] = {
+      val ref             = typeTranslator.asScType(defn.id, domain, evolution).fullyQualified
+      val unmodifiedSince = evolution.typesUnchangedSince(domain.version)(defn.id).sameIn.map(v => s"\"${v.v.toString}\"")
+      val sameInVersion = MetaField(
+        q"def baboonSameInVersions: $scList[$scString]",
+        q"List(${unmodifiedSince.mkString(", ")})",
+        q"$ref.baboonSameInVersions",
+      )
+      List(sameInVersion)
+    }
+  }
+}
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala
index 63daf0f9..6601efdd 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala
@@ -1,7 +1,9 @@
 package io.septimalmind.baboon.translator.scl
 
 import io.septimalmind.baboon.CompilerTarget.ScTarget
+import io.septimalmind.baboon.parser.model.DerivationDecl
 import io.septimalmind.baboon.translator.scl.ScCodecTranslator.CodecMeta
+import io.septimalmind.baboon.translator.scl.ScDomainTreeTools.MetaField
 import io.septimalmind.baboon.translator.scl.ScTypes.*
 import io.septimalmind.baboon.typer.model.*
 import izumi.fundamentals.platform.strings.TextTree
@@ -12,127 +14,99 @@ class ScJsonCodecGenerator(
   target: ScTarget,
   domain: Domain,
   evo: BaboonEvolution,
-  csTypeInfo: ScTypeInfo,
+  scTypeInfo: ScTypeInfo,
+  scDomainTreeTools: ScDomainTreeTools,
 ) extends ScCodecTranslator {
 
   override def translate(defn: DomainMember.User, csRef: ScValue.ScType, srcRef: ScValue.ScType): Option[TextTree[ScValue]] = {
-    val isLatestVersion = domain.version == evo.latest
-
-    (defn.defn match {
-      case d: Typedef.Dto =>
-        Some(genDtoBodies(csRef, d))
-      case _: Typedef.Enum =>
-        Some(genEnumBodies(csRef))
-      case a: Typedef.Adt =>
-        Some(genAdtBodies(csRef, a))
-      case _: Typedef.Foreign =>
-        Some(genForeignBodies(csRef))
-      case _: Typedef.Contract =>
-        None
-      case _: Typedef.Service =>
-        None
-    }).map {
-      case (enc, dec) =>
-        if (!isLatestVersion) {
-          (q"""throw new Exception("Type ${defn.id.toString}@${domain.version.toString} is deprecated, encoder was not generated");""", dec)
-        } else {
-          (enc, dec)
-        }
-    }.map {
-      case (enc, dec) =>
-        val insulatedEnc =
-          q"""if (this ne LazyInstance.value)
-             |{
-             |  return LazyInstance.value.encode(ctx, value);
-             |}
-             |
-             |$enc
-             |""".stripMargin.trim
+    if (isActive(defn.id)) {
+      (defn.defn match {
+        case d: Typedef.Dto      => Some(genDtoBodies(csRef, d))
+        case _: Typedef.Enum     => Some(genEnumBodies(csRef))
+        case a: Typedef.Adt      => Some(genAdtBodies(csRef, a))
+        case _: Typedef.Foreign  => Some(genForeignBodies(csRef))
+        case _: Typedef.Contract => None
+        case _: Typedef.Service  => None
+      }).map {
+        case (enc, dec) =>
+          val insulatedEnc =
+            q"""if (this ne LazyInstance.value) {
+               |  return LazyInstance.value.encode(ctx, value)
+               |}
+               |
+               |$enc
+               |""".stripMargin.trim
+
+          val insulatedDec =
+            q"""if (this ne LazyInstance.value) {
+               |  return LazyInstance.value.decode(ctx, wire)
+               |}
+               |
+               |$dec
+               |""".stripMargin.trim
+
+          genCodec(
+            defn,
+            csRef,
+            srcRef,
+            insulatedEnc,
+            insulatedDec,
+          )
+      }
+    } else None
+  }
 
-        val insulatedDec =
-          q"""if (this ne LazyInstance.value)
-             |{
-             |  return LazyInstance.value.decode(ctx, wire);
+  private def genCodec(
+    defn: DomainMember.User,
+    name: ScValue.ScType,
+    srcRef: ScValue.ScType,
+    enc: TextTree[ScValue],
+    dec: TextTree[ScValue],
+  ): TextTree[ScValue] = {
+    val isEncoderEnabled = target.language.enableDeprecatedEncoders || domain.version == evo.latest
+    val iName            = q"$baboonJsonCodec[$name]"
+    val encodeMethod =
+      if (isEncoderEnabled) {
+        List(
+          q"""def encode(ctx: $baboonCodecContext, value: $name): io.circe.Json = {
+             |  ${enc.shift(2).trim}
              |}
-             |
-             |$dec
              |""".stripMargin.trim
-
-        genCodec(
-          defn,
-          csRef,
-          srcRef,
-          insulatedEnc,
-          insulatedDec,
-          !defn.defn.isInstanceOf[Typedef.Foreign],
         )
-    }
-  }
-
-  private def genCodec(defn: DomainMember.User, name: ScValue.ScType, srcRef: ScValue.ScType, enc: TextTree[ScValue], dec: TextTree[ScValue], addExtensions: Boolean)
-    : TextTree[ScValue] = {
-    val iName = q"$baboonJsonCodec[$name]"
-    val baseMethods = List(
-      q"""def encode(ctx: $baboonCodecContext, value: $name): io.circe.Json = {
-         |  ${enc.shift(2).trim}
-         |}
-         |
-         |def decode(ctx: $baboonCodecContext, wire: io.circe.Json): Either[String, $name] = {
-         |  ${dec.shift(2).trim}
-         |}""".stripMargin.trim
-    )
-
-    val (parents, methods) = defn.defn match {
-      case _: Typedef.Enum =>
-        (List(q"$baboonJsonCodec[$name]"), baseMethods)
-      case _ =>
-//        val extensions = List(
-//          q"""def encode(ctx: $baboonCodecContext, value: $iBaboonGenerated): io.circe.Json = {
-//             |  if (value.isInstanceOf[$name]) {
-//             |    encode(ctx, value.asInstanceOf[$name])
-//             |  } else {
-//             |    throw new Exception(s"Expected to have ${name.name} type")
-//             |  }
-//             |}
-//             |
-//             |def decode(ctx: $baboonCodecContext, wire: io.circe.Json): Either[String, $iBaboonGenerated] = {
-//             |  decode(ctx, wire).map(Right(_)).left.map(Left.apply)
-//             |}""".stripMargin
-//        )
-
-        val adtParents = defn.id.owner match {
-          case Owner.Adt(_) => List(q"$iBaboonAdtMemberMeta")
-          case _            => List.empty
-
-        }
-        val extParents = adtParents
-
-        val mm = if (addExtensions) {
-          baseMethods // ++ extensions
-        } else {
-          baseMethods
-        }
-
-        val baseParents = List(iName)
-        val pp = if (addExtensions) {
-          baseParents ++ extParents
-        } else {
-          baseParents
-        }
-
-        (pp, mm)
+      } else Nil
+    val decodeMethod =
+      List(
+        q"""def decode(ctx: $baboonCodecContext, wire: io.circe.Json): Either[String, $name] = {
+           |  ${dec.shift(2).trim}
+           |}""".stripMargin.trim
+      )
+
+    val baseMethods = encodeMethod ++ decodeMethod
+    val cName       = codecName(srcRef)
+    val cParent = if (isEncoderEnabled) {
+      defn match {
+        case DomainMember.User(_, _: Typedef.Enum, _, _)    => q"$baboonJsonCodecBase[$name, $iName]"
+        case DomainMember.User(_, _: Typedef.Foreign, _, _) => q"$baboonJsonCodecBase[$name, $iName]"
+        case _ if defn.isAdt                                => q"$baboonJsonCodecBaseGeneratedAdt[$name, $iName]"
+        case _                                              => q"$baboonJsonCodecBaseGenerated[$name, $iName]"
+      }
+    } else {
+      defn match {
+        case DomainMember.User(_, _: Typedef.Enum, _, _)    => q"$baboonJsonCodecNoEncoder[$name, $iName]"
+        case DomainMember.User(_, _: Typedef.Foreign, _, _) => q"$baboonJsonCodecNoEncoder[$name, $iName]"
+        case _ if defn.isAdt                                => q"$baboonJsonCodecNoEncoderGeneratedAdt[$name, $iName]"
+        case _                                              => q"$baboonJsonCodecNoEncoderGenerated[$name, $iName]"
+      }
     }
 
-    val cName = codecName(srcRef)
-    val meta  = q"" // csDomTrees.makeMeta(defn, isCodec = true).join("\n")
-    q"""object ${cName.asName} extends ${parents.join(" with ")} {
-       |  ${methods.join("\n\n").shift(2).trim}
-       |
-       |  ${meta.shift(2).trim}
+    val meta = renderMeta(defn, scDomainTreeTools.makeCodecMeta(defn))
+    q"""object ${cName.asName} extends $cParent {
+       |  ${baseMethods.joinNN().shift(2).trim}
        |
-       |  private val LazyInstance: $baboonLazy[$iName] = $baboonLazy($cName)
+       |  ${meta.joinN().shift(2).trim}
        |
-       |  def instance: $iName = LazyInstance.value
+       |  override protected def LazyInstance: $baboonLazy[$iName] = $baboonLazy($cName)
+       |  override def instance: $iName = LazyInstance.value
        |}
        |""".stripMargin
   }
@@ -154,10 +128,9 @@ class ScJsonCodecGenerator(
   }
 
   private def genAdtBodies(name: ScValue.ScType, a: Typedef.Adt): (TextTree[ScValue], TextTree[Nothing]) = {
-
     val branches = a.dataMembers(domain).map {
       m =>
-        val branchNs            = q"${csTypeInfo.adtNsName(a.id)}"
+        val branchNs            = q"${scTypeInfo.adtNsName(a.id)}"
         val branchName          = m.name.name
         val fqBranch            = q"$branchNs.$branchName"
         val branchNameRef       = q"${branchName.toLowerCase}"
@@ -169,28 +142,24 @@ class ScJsonCodecGenerator(
           wrapAdtBranchEncoder(branchName, routedBranchEncoder)
         }
 
-        val branchValue = if (target.language.wrappedAdtBranchCodecs) {
-          q"wire"
-        } else {
-          q"head._2"
-        }
+        val branchValue = if (target.language.wrappedAdtBranchCodecs) q"wire" else q"head._2"
 
         (
-          q"""case $branchNameRef: $fqBranch => {
+          q"""case $branchNameRef: $fqBranch => 
              |  $branchEncoder
-             |}""".stripMargin,
-          q"""if (head._1 == "$branchName") {
-             |  return ${fqBranch}_JsonCodec.instance.decode(ctx, $branchValue)
-             |}""".stripMargin,
+             |""".stripMargin,
+          q"""case "$branchName" =>
+             |  ${fqBranch}_JsonCodec.instance.decode(ctx, $branchValue)
+             |""".stripMargin,
         )
 
     }
 
     (
       q"""value match {
-         |  ${branches.map(_._1).join("\n").shift(2).trim}
-         |  case _ => 
-         |    throw new IllegalArgumentException(s"Cannot encode $$value: unexpected subclass")
+         |  ${branches.map(_._1).joinN().shift(2).trim}
+         |  
+         |  case _ => throw new IllegalArgumentException(s"Cannot encode $$value: unexpected subclass")
          |}
          |
          |
@@ -201,9 +170,11 @@ class ScJsonCodecGenerator(
          |}
          |val head = asObject.get.toList.head
          |
-         |${branches.map(_._2).join("\n")}
+         |head._1 match {
+         |  ${branches.map(_._2).joinN().shift(2).trim}
          |
-         |throw new IllegalArgumentException(s"Cannot decode $$wire to ${name.name}: no matching value")
+         |  case _ =>  throw new IllegalArgumentException(s"Cannot decode $$wire to ${name.name}: no matching value")
+         |}
          |""".stripMargin,
     )
   }
@@ -232,7 +203,7 @@ class ScJsonCodecGenerator(
         val enc      = mkEncoder(f.tpe, fieldRef)
         val dec      = mkDecoder(f.tpe, q"""asObject("${f.name.name}")""")
         (
-          q"""("${f.name.name}" -> $enc)""",
+          q""""${f.name.name}" -> $enc""",
           q"${f.name.name} = $dec",
         )
     }
@@ -241,14 +212,11 @@ class ScJsonCodecGenerator(
                      |  ${fields.map(_._1).join(",\n").shift(2).trim}
                      |)""".stripMargin
 
-    val fullEnc = d.id.owner match {
-      case Owner.Adt(_) if target.language.wrappedAdtBranchCodecs =>
-        wrapAdtBranchEncoder(d.id.name.name, mainEnc)
-      case _ => mainEnc
+    val encBody = d.id.owner match {
+      case Owner.Adt(_) if target.language.wrappedAdtBranchCodecs => wrapAdtBranchEncoder(d.id.name.name, mainEnc)
+      case _                                                      => mainEnc
     }
 
-    val encBody = q"""return $fullEnc"""
-
     val fullDec = d.id.owner match {
       case Owner.Adt(_) if target.language.wrappedAdtBranchCodecs => q"wire.asObject.get.toList.head._2.asObject.get"
       case _                                                      => q"wire.asObject.get"
@@ -256,10 +224,6 @@ class ScJsonCodecGenerator(
 
     val decBody =
       q"""val asObject = $fullDec
-         |
-         |/*if (asObject.isEmpty) {
-         |  throw new IllegalArgumentException(s"Cannot decode $$wire to ${name.name}: object expected")
-         |}*/
          |
          |Right($name(
          |  ${fields.map(_._2).join(",\n").shift(2).trim}
@@ -446,17 +410,27 @@ class ScJsonCodecGenerator(
 
   }
 
+  private def renderMeta(defn: DomainMember.User, meta: List[MetaField]): List[TextTree[ScValue]] = {
+    defn.defn match {
+      case _: Typedef.Enum | _: Typedef.Foreign => meta.map(_.valueField)
+      case _                                    => meta.map(_.refValueField)
+    }
+  }
+
   def codecName(name: ScValue.ScType): ScValue.ScType = {
     ScValue.ScType(name.pkg, s"${name.name}_JsonCodec", name.fq)
   }
 
-  override def codecMeta(defn: DomainMember.User, name: ScValue.ScType): CodecMeta = {
-//    val fix = csDomTrees.metaMethodFlags(defn, isCodec = false)
-    val fix = q""
-    val member =
-      q"""def $fix$baboonJsonCodec[$name] codec_JSON(): $name = {
-         |  ${codecName(name)}.instance
-         |}""".stripMargin
-    CodecMeta(member)
+  override def codecMeta(defn: DomainMember.User, name: ScValue.ScType): Option[CodecMeta] = {
+    if (isActive(defn.id)) {
+      Some(CodecMeta(q"def codecJson: $baboonJsonCodec[$name] = ${codecName(name)}.instance"))
+    } else None
   }
+
+  override def isActive(id: TypeId): Boolean = {
+    target.language.generateJsonCodecs && (target.language.generateJsonCodecsByDefault || domain.derivationRequests
+      .getOrElse(DerivationDecl("json"), Set.empty[TypeId]).contains(id))
+  }
+
+  override def id: String = "Json"
 }
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTreeTools.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTreeTools.scala
index 5e856ea5..8db8be34 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTreeTools.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTreeTools.scala
@@ -8,7 +8,7 @@ trait ScTreeTools {
 }
 
 object ScTreeTools {
-  class ScTreeToolsImpl() extends ScTreeTools {
+  class ScTreeToolsImpl extends ScTreeTools {
     def inNs(nss: Seq[String], tree: TextTree[ScValue]): TextTree[ScValue] = {
       if (nss.isEmpty) {
         tree
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeInfo.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeInfo.scala
index 3b3a055e..13e7a3d5 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeInfo.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeInfo.scala
@@ -2,7 +2,7 @@ package io.septimalmind.baboon.translator.scl
 
 import io.septimalmind.baboon.typer.model.TypeId
 
-class ScTypeInfo() {
+class ScTypeInfo {
   def adtNsName(id: TypeId.User): String = {
     id.name.name
   }
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeTranslator.scala
index 98a57e81..dcf0ac58 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeTranslator.scala
@@ -81,7 +81,7 @@ class ScTypeTranslator(
         assert(parts.length > 1)
         val pkg = parts.init
         val id  = parts.last
-        ScType(ScPackageId(NEList.unsafeFrom(pkg)), id, fq = false)
+        ScType(ScPackageId(NEList.unsafeFrom(pkg)), id)
       case _ =>
         toScTypeRefKeepForeigns(tid, domain, evolution)
     }
@@ -100,7 +100,7 @@ class ScTypeTranslator(
       case _ =>
         ScPackageId(fullPrefix)
     }
-    ScType(fullPkg, tid.name.name.capitalize, fq = false)
+    ScType(fullPkg, tid.name.name.capitalize)
   }
 
   private def renderOwner(owner: Owner): Seq[String] = {
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypes.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypes.scala
index c303a08e..cc19e237 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypes.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypes.scala
@@ -3,75 +3,91 @@ import io.septimalmind.baboon.translator.scl.ScValue.{ScPackageId, ScType}
 import izumi.fundamentals.collections.nonempty.NEList
 
 object ScTypes {
+  // baboon packages
   val baboonRuntimePkg: ScPackageId = parseScPkg("_root_.baboon.runtime.shared")
-
-  val baboonTypeCodecs: ScType = ScType(baboonRuntimePkg, "BaboonTypeCodecs")
-
-  val iBaboonGenerated: ScType          = ScType(baboonRuntimePkg, "BaboonGenerated")
-  val iBaboonAdtMemberMeta: ScType      = ScType(baboonRuntimePkg, "BaboonAdtMemberMeta")
-  val iBaboonGeneratedLatest: ScType    = ScType(baboonRuntimePkg, "BaboonGeneratedLatest")
-  val abstractBaboonConversion: ScType  = ScType(baboonRuntimePkg, "BaboonAbstractConversion")
-  val abstractBaboonConversions: ScType = ScType(baboonRuntimePkg, "BaboonAbstractConversions")
-  val abstractBaboonCodecs: ScType      = ScType(baboonRuntimePkg, "BaboonAbstractCodecs")
-  val baboonEnum: ScType                = ScType(baboonRuntimePkg, "BaboonEnum")
-  val baboonMeta: ScType                = ScType(baboonRuntimePkg, "BaboonMeta")
-  val baboonFixture: ScType             = ScType(baboonRuntimePkg, "BaboonFixture")
-  val baboonAdtFixture: ScType          = ScType(baboonRuntimePkg, "BaboonAdtFixture")
-  val baboonRandom: ScType              = ScType(baboonRuntimePkg, "BaboonRandom")
-  val baboonJsonCodec: ScType           = ScType(baboonRuntimePkg, "BaboonJsonCodec")
-  val baboonBinCodec: ScType            = ScType(baboonRuntimePkg, "BaboonBinCodec")
-  val baboonBinCodecIndexed: ScType     = ScType(baboonRuntimePkg, "BaboonBinCodecIndexed")
-  val baboonTimeFormats: ScType         = ScType(baboonRuntimePkg, "BaboonTimeFormats")
-  val baboonTools: ScType               = ScType(baboonRuntimePkg, "BaboonTools")
-  val baboonCodecContext: ScType        = ScType(baboonRuntimePkg, "BaboonCodecContext")
-  val baboonLazy: ScType                = ScType(baboonRuntimePkg, "Lazy")
-  val baboonBinTools: ScType            = ScType(baboonRuntimePkg, "BaboonBinTools")
-  val scByteString: ScType              = ScType(baboonRuntimePkg, "ByteString")
-
-  val binaryInput: ScType  = ScType(baboonRuntimePkg, "LEDataInputStream")
-  val binaryOutput: ScType = ScType(baboonRuntimePkg, "LEDataOutputStream")
+  val baboonFixturePkg: ScPackageId = parseScPkg("_root_.baboon.fixture")
+
+  // baboon metadata
+  val iBaboonGenerated: ScType       = ScType(baboonRuntimePkg, "BaboonGenerated")
+  val iBaboonAdtMemberMeta: ScType   = ScType(baboonRuntimePkg, "BaboonAdtMemberMeta")
+  val iBaboonGeneratedLatest: ScType = ScType(baboonRuntimePkg, "BaboonGeneratedLatest")
+  val baboonEnum: ScType             = ScType(baboonRuntimePkg, "BaboonEnum")
+  val baboonMeta: ScType             = ScType(baboonRuntimePkg, "BaboonMeta")
+
+  // baboon codecs types
+  val baboonJsonCodec: ScType                      = ScType(baboonRuntimePkg, "BaboonJsonCodec")
+  val baboonJsonCodecBase: ScType                  = ScType(baboonRuntimePkg, "BaboonJsonCodec.Base")
+  val baboonJsonCodecBaseGenerated: ScType         = ScType(baboonRuntimePkg, "BaboonJsonCodec.BaseGenerated")
+  val baboonJsonCodecBaseGeneratedAdt: ScType      = ScType(baboonRuntimePkg, "BaboonJsonCodec.BaseGeneratedAdt")
+  val baboonJsonCodecNoEncoder: ScType             = ScType(baboonRuntimePkg, "BaboonJsonCodec.NoEncoder")
+  val baboonJsonCodecNoEncoderGenerated: ScType    = ScType(baboonRuntimePkg, "BaboonJsonCodec.NoEncoderGenerated")
+  val baboonJsonCodecNoEncoderGeneratedAdt: ScType = ScType(baboonRuntimePkg, "BaboonJsonCodec.NoEncoderGeneratedAdt")
+
+  val baboonBinCodec: ScType                      = ScType(baboonRuntimePkg, "BaboonBinCodec")
+  val baboonBinCodecBase: ScType                  = ScType(baboonRuntimePkg, "BaboonBinCodec.Base")
+  val baboonBinCodecBaseGenerated: ScType         = ScType(baboonRuntimePkg, "BaboonBinCodec.BaseGenerated")
+  val baboonBinCodecBaseGeneratedAdt: ScType      = ScType(baboonRuntimePkg, "BaboonBinCodec.BaseGeneratedAdt")
+  val baboonBinCodecNoEncoder: ScType             = ScType(baboonRuntimePkg, "BaboonBinCodec.NoEncoder")
+  val baboonBinCodecNoEncoderGenerated: ScType    = ScType(baboonRuntimePkg, "BaboonBinCodec.NoEncoderGenerated")
+  val baboonBinCodecNoEncoderGeneratedAdt: ScType = ScType(baboonRuntimePkg, "BaboonBinCodec.NoEncoderGeneratedAdt")
+
+  // baboon types
+  val baboonBinCodecIndexed: ScType           = ScType(baboonRuntimePkg, "BaboonBinCodecIndexed")
+  val baboonCodecContext: ScType              = ScType(baboonRuntimePkg, "BaboonCodecContext")
+  def abstractBaboonCodec(id: String): ScType = ScType(baboonRuntimePkg, s"AbstractBaboon${id}Codecs")
+  val binaryInput: ScType                     = ScType(baboonRuntimePkg, "LEDataInputStream")
+  val binaryOutput: ScType                    = ScType(baboonRuntimePkg, "LEDataOutputStream")
+  val baboonTimeFormats: ScType               = ScType(baboonRuntimePkg, "BaboonTimeFormats")
+  val baboonLazy: ScType                      = ScType(baboonRuntimePkg, "Lazy")
+  val baboonBinTools: ScType                  = ScType(baboonRuntimePkg, "BaboonBinTools")
+  val scByteString: ScType                    = ScType(baboonRuntimePkg, "ByteString")
+  val baboonRandom: ScType                    = ScType(baboonFixturePkg, "BaboonRandom")
+
+  // baboon conversions
+  val baboonAbstractConversion  = ScType(baboonRuntimePkg, "AbstractConversion")
+  val baboonAbstractConversions = ScType(baboonRuntimePkg, "AbstractBaboonConversions")
 
   val scalaPkg: ScPackageId = parseScPkg("_root_.scala")
 
   val deprecated: ScType = ScType(scalaPkg, "deprecated")
 
-  val scBoolean: ScType    = ScType(scalaPkg, "Boolean")
-  val scByte: ScType       = ScType(scalaPkg, "Byte")
-  val scShort: ScType      = ScType(scalaPkg, "Short")
-  val scInt: ScType        = ScType(scalaPkg, "Int")
-  val scLong: ScType       = ScType(scalaPkg, "Long")
-  val scFloat: ScType      = ScType(scalaPkg, "Float")
-  val scDouble: ScType     = ScType(scalaPkg, "Double")
-  val scBigDecimal: ScType = ScType(scalaPkg, "BigDecimal")
-  val scUnit: ScType       = ScType(scalaPkg, "Unit")
-  val scArray: ScType      = ScType(scalaPkg, "Array")
+  val scBoolean: ScType    = ScType(scalaPkg, "Boolean", predef = true)
+  val scByte: ScType       = ScType(scalaPkg, "Byte", predef = true)
+  val scShort: ScType      = ScType(scalaPkg, "Short", predef = true)
+  val scInt: ScType        = ScType(scalaPkg, "Int", predef = true)
+  val scLong: ScType       = ScType(scalaPkg, "Long", predef = true)
+  val scFloat: ScType      = ScType(scalaPkg, "Float", predef = true)
+  val scDouble: ScType     = ScType(scalaPkg, "Double", predef = true)
+  val scBigDecimal: ScType = ScType(scalaPkg, "BigDecimal", predef = true)
+  val scUnit: ScType       = ScType(scalaPkg, "Unit", predef = true)
+  val scArray: ScType      = ScType(scalaPkg, "Array", predef = true)
 
   // Scala collection types
   val scOption: ScType = ScType(scalaPkg, "Option")
 
-  val scalaCollImmuPkg: ScPackageId = parseScPkg("_root_.scala.collection.immutable")
-  val scList: ScType                = ScType(scalaCollImmuPkg, "List")
-  val scSet: ScType                 = ScType(scalaCollImmuPkg, "Set")
-  val scMap: ScType                 = ScType(scalaCollImmuPkg, "Map")
+  val scalaCollImmuPkg: ScPackageId = parseScPkg("scala.collection.immutable")
+  val scList: ScType                = ScType(scalaCollImmuPkg, "List", predef = true)
+  val scSet: ScType                 = ScType(scalaCollImmuPkg, "Set", predef = true)
+  val scMap: ScType                 = ScType(scalaCollImmuPkg, "Map", predef = true)
 
-  val scalaCollMutPkg: ScPackageId = parseScPkg("_root_.scala.collection.mutable")
-  val scMutMap: ScType             = ScType(scalaCollMutPkg, "Map")
+  val scalaCollMutPkg: ScPackageId = parseScPkg("scala.collection.mutable")
+  val scMutMap: ScType             = ScType(scalaCollMutPkg, "Map", predef = true)
 
-  val scalaUtilPkg: ScPackageId = parseScPkg("_root_.scala.util")
-  val scEither: ScType          = ScType(scalaUtilPkg, "Either")
-  val scRandom: ScType          = ScType(scalaUtilPkg, "Random")
+  val scalaUtilPkg: ScPackageId = parseScPkg("scala.util")
+  val scEither: ScType          = ScType(scalaUtilPkg, "Either", predef = true)
 
-  val javaUtilPkg: ScPackageId = parseScPkg("_root_.java.util")
+  val javaUtilPkg: ScPackageId = parseScPkg("java.util")
   val scUid: ScType            = ScType(javaUtilPkg, "UUID")
 
-  val javaLangPkg: ScPackageId = parseScPkg("_root_.java.lang")
-  val scString: ScType         = ScType(javaLangPkg, "String")
+  val javaLangPkg: ScPackageId = parseScPkg("java.lang")
+  val scString: ScType         = ScType(javaLangPkg, "String", predef = true)
   val genericException: ScType = ScType(javaLangPkg, "RuntimeException")
+  val javaClass: ScType        = ScType(javaLangPkg, "Class", predef = true)
 
-  val javaTimePkg: ScPackageId = parseScPkg("_root_.java.time")
+  val javaTimePkg: ScPackageId = parseScPkg("java.time")
   val scTime: ScType           = ScType(javaTimePkg, "OffsetDateTime")
 
-  val javaIoPkg: ScPackageId = parseScPkg("_root_.java.io")
+  val javaIoPkg: ScPackageId = parseScPkg("java.io")
 
   val byteArrayOutputStream: ScType = ScType(javaIoPkg, "ByteArrayOutputStream")
   val javaFile: ScType              = ScType(javaIoPkg, "File")
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala
index 65da515e..2f62fdb3 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala
@@ -1,10 +1,11 @@
 package io.septimalmind.baboon.translator.scl
 
 import io.septimalmind.baboon.CompilerTarget.ScTarget
-import io.septimalmind.baboon.translator.scl
+import io.septimalmind.baboon.parser.model.DerivationDecl
 import io.septimalmind.baboon.translator.scl.ScCodecTranslator.CodecMeta
+import io.septimalmind.baboon.translator.scl.ScDomainTreeTools.MetaField
 import io.septimalmind.baboon.translator.scl.ScTypes.*
-import io.septimalmind.baboon.typer.model.{BaboonEvolution, BinReprLen, Domain, DomainMember, Owner, TypeId, TypeRef, Typedef}
+import io.septimalmind.baboon.typer.model.*
 import izumi.fundamentals.platform.strings.TextTree
 import izumi.fundamentals.platform.strings.TextTree.*
 
@@ -14,6 +15,7 @@ class ScUEBACodecGenerator(
   domain: Domain,
   evo: BaboonEvolution,
   csTypeInfo: ScTypeInfo,
+  scDomainTreeTools: ScDomainTreeTools,
 ) extends ScCodecTranslator {
 
   override def translate(
@@ -21,59 +23,49 @@ class ScUEBACodecGenerator(
     csRef: ScValue.ScType,
     srcRef: ScValue.ScType,
   ): Option[TextTree[ScValue]] = {
-    val isLatestVersion = domain.version == evo.latest
-
-    (defn.defn match {
-      case d: Typedef.Dto      => Some(genDtoBodies(csRef, d))
-      case e: Typedef.Enum     => Some(genEnumBodies(csRef, e))
-      case a: Typedef.Adt      => Some(genAdtBodies(csRef, a))
-      case _: Typedef.Foreign  => Some(genForeignBodies(csRef))
-      case _: Typedef.Contract => None
-      case _: Typedef.Service  => None
-    }).map {
-      case (enc, dec) =>
-        if (!isLatestVersion) {
-          (q"""throw new RuntimeException("Type ${defn.id.toString}@${domain.version.toString} is deprecated, encoder was not generated")""", dec)
-        } else {
-          (enc, dec)
-        }
-    }.map {
-      case (enc, dec) =>
-        // plumbing reference leaks
-        val insulatedEnc =
-          q"""if (this ne LazyInstance.value)
-             |{
-             |  LazyInstance.value.encode(ctx, writer, value)
-             |  return
-             |}
-             |
-             |$enc
-             |""".stripMargin.trim
-
-        val insulatedDec =
-          q"""if (this ne LazyInstance.value)
-             |{
-             |  return LazyInstance.value.decode(ctx, wire)
-             |}
-             |
-             |$dec
-             |""".stripMargin.trim
-
-        val branchDecoder = defn.defn match {
-          case d: Typedef.Dto => genBranchDecoder(csRef, d)
-          case _              => None
-        }
+    if (isActive(defn.id)) {
+      (defn.defn match {
+        case d: Typedef.Dto      => Some(genDtoBodies(csRef, d))
+        case e: Typedef.Enum     => Some(genEnumBodies(csRef, e))
+        case a: Typedef.Adt      => Some(genAdtBodies(csRef, a))
+        case _: Typedef.Foreign  => Some(genForeignBodies(csRef))
+        case _: Typedef.Contract => None
+        case _: Typedef.Service  => None
+      }).map {
+        case (enc, dec) =>
+          // plumbing reference leaks
+          val insulatedEnc =
+            q"""if (this ne LazyInstance.value) {
+               |  LazyInstance.value.encode(ctx, writer, value)
+               |  return
+               |}
+               |
+               |$enc
+               |""".stripMargin.trim
 
-        genCodec(
-          defn,
-          csRef,
-          srcRef,
-          insulatedEnc,
-          insulatedDec,
-          !defn.defn.isInstanceOf[Typedef.Foreign],
-          branchDecoder,
-        )
-    }
+          val insulatedDec =
+            q"""if (this ne LazyInstance.value) {
+               |  return LazyInstance.value.decode(ctx, wire)
+               |}
+               |
+               |$dec
+               |""".stripMargin.trim
+
+          val branchDecoder = defn.defn match {
+            case d: Typedef.Dto => genBranchDecoder(csRef, d)
+            case _              => None
+          }
+
+          genCodec(
+            defn,
+            csRef,
+            srcRef,
+            insulatedEnc,
+            insulatedDec,
+            branchDecoder,
+          )
+      }
+    } else None
   }
 
   private def genCodec(
@@ -82,13 +74,13 @@ class ScUEBACodecGenerator(
     srcRef: ScValue.ScType,
     enc: TextTree[ScValue],
     dec: TextTree[ScValue],
-    addExtensions: Boolean,
     branchDecoder: Option[TextTree[ScValue]],
   ): TextTree[ScValue] = {
+    val isEncoderEnabled = target.language.enableDeprecatedEncoders || domain.version == evo.latest
     val indexBody = defn.defn match {
       case d: Typedef.Dto =>
         val varlens = d.fields.filter(f => domain.refMeta(f.tpe).len.isVariable)
-        val comment = varlens.map(f => q"// ${f.toString}").join("\n")
+        val comment = varlens.map(f => q"// ${f.toString}").joinN()
         q"""$comment
            |${varlens.size.toString}""".stripMargin
 
@@ -108,93 +100,68 @@ class ScUEBACodecGenerator(
          |}""".stripMargin
     )
 
-    val baseMethods = List(
-      q"""def encode(ctx: $baboonCodecContext, writer: $binaryOutput, value: $name): $scUnit = {
-         |  ${enc.shift(2).trim}
-         |}
-         |
-         |def decode(ctx: $baboonCodecContext, wire: $binaryInput): $name = {
+    val encoderMethods = if (isEncoderEnabled) {
+      List(
+        q"""def encode(ctx: $baboonCodecContext, writer: $binaryOutput, value: $name): $scUnit = {
+           |  ${enc.shift(2).trim}
+           |}
+           |""".stripMargin
+      )
+    } else Nil
+
+    val decoderMethods = List(
+      q"""def decode(ctx: $baboonCodecContext, wire: $binaryInput): $name = {
          |  ${dec.shift(2).trim}
          |}""".stripMargin
-    ) ++ branchDecoder.map {
-      body =>
-        q"""def decodeBranch(ctx: $baboonCodecContext, wire: $binaryInput): $name = {
-           |  ${body.shift(2).trim}
-           |}""".stripMargin
-    }.toList ++ indexMethods
-
-    val codecIface = q"$baboonBinCodec[$name]"
-    val (parents, methods) = defn.defn match {
-      case _: Typedef.Enum =>
-        (List(q"$baboonBinCodec[$name]", q"$baboonBinCodecIndexed"), baseMethods)
-      case _ =>
-        val extensions = List(
-//          q"""def encode(ctx: $baboonCodecContext, writer: $binaryOutput, value: $iBaboonGenerated) = {
-//             |  if (!value.isInstanceOf[$name])
-//             |      throw new Exception("Expected to have ${name.name} type")
-//             |
-//             |  encode(ctx, writer, dvalue)
-//             |}""".stripMargin
-//          q"""$iBaboonGenerated $iBaboonStreamCodec<$iBaboonGenerated, $binaryOutput, $binaryInput>.decode($baboonCodecContext ctx, $binaryInput wire)
-//             |{
-//             |    return Decode(ctx, wire);
-//             |}""".stripMargin,
-        )
-
-        val adtParents = defn.id.owner match {
-          case Owner.Adt(_) => List(q"$iBaboonAdtMemberMeta")
-          case _            => List.empty
-        }
-        val extParents = /*List(q"$baboonBinCodec[$iBaboonGenerated]") ++*/ adtParents
-
-        val mm = if (addExtensions) {
-          baseMethods ++ extensions
-        } else {
-          baseMethods
-        }
-
-        val baseParents = List(codecIface, q"$baboonBinCodecIndexed")
+    )
 
-        val pp = if (addExtensions) {
-          baseParents ++ extParents
-        } else {
-          baseParents
-        }
+    val baseMethods = encoderMethods ++ decoderMethods
+      ++ branchDecoder.map {
+        body =>
+          q"""def decodeBranch(ctx: $baboonCodecContext, wire: $binaryInput): $name = {
+             |  ${body.shift(2).trim}
+             |}""".stripMargin
+      }.toList ++ indexMethods
 
-        (pp, mm)
+    val codecIface = q"$baboonBinCodec[$name]"
+    val cName      = codecName(srcRef)
+    val cParent = if (isEncoderEnabled) {
+      defn match {
+        case DomainMember.User(_, _: Typedef.Enum, _, _)    => q"$baboonBinCodecBase[$name, $codecIface]"
+        case DomainMember.User(_, _: Typedef.Foreign, _, _) => q"$baboonBinCodecBase[$name, $codecIface]"
+        case _ if defn.isAdt                                => q"$baboonBinCodecBaseGeneratedAdt[$name, $codecIface]"
+        case _                                              => q"$baboonBinCodecBaseGenerated[$name, $codecIface]"
+      }
+    } else {
+      defn match {
+        case DomainMember.User(_, _: Typedef.Enum, _, _)    => q"$baboonBinCodecNoEncoder[$name, $codecIface]"
+        case DomainMember.User(_, _: Typedef.Foreign, _, _) => q"$baboonBinCodecNoEncoder[$name, $codecIface]"
+        case _ if defn.isAdt                                => q"$baboonBinCodecNoEncoderGeneratedAdt[$name, $codecIface]"
+        case _                                              => q"$baboonBinCodecNoEncoderGenerated[$name, $codecIface]"
+      }
     }
-
-    val cName = codecName(srcRef)
-
-    val meta = q""
-    /**
-      * csDomTrees
-      * .makeMeta(defn, isCodec = true)
-      * .join("\n")
-      * .shift(2)
-      * .trim
-      */
+    val parents = List(cParent, q"$baboonBinCodecIndexed")
+    val meta    = renderMeta(defn, scDomainTreeTools.makeCodecMeta(defn))
 
     q"""object ${cName.asName} extends ${parents.join(" with ")} {
-       |  ${methods.join("\n\n").shift(2).trim}
-       |
-       |  ${meta.shift(2).trim}
+       |  ${baseMethods.joinNN().shift(2).trim}
        |
-       |  private val LazyInstance: $baboonLazy[$codecIface] = $baboonLazy($cName)
+       |  ${meta.joinN().shift(2).trim}
        |
-       |  def instance: $codecIface = LazyInstance.value
+       |  override protected def LazyInstance: $baboonLazy[$codecIface] = $baboonLazy($cName)
+       |  override def instance: $codecIface = LazyInstance.value
        |}
      """.stripMargin
   }
 
-  private def genForeignBodies(name: ScValue.ScType) = {
+  private def genForeignBodies(name: ScValue.ScType): (TextTree[Nothing], TextTree[Nothing]) = {
     (
       q"""throw new IllegalArgumentException("${name.name} is a foreign type")""",
       q"""throw new IllegalArgumentException("${name.name} is a foreign type")""",
     )
   }
 
-  private def genAdtBodies(name: ScValue.ScType, a: Typedef.Adt) = {
+  private def genAdtBodies(name: ScValue.ScType, a: Typedef.Adt): (TextTree[ScValue.ScType], TextTree[ScValue.ScType]) = {
     val branches = a.dataMembers(domain).zipWithIndex.toList.map {
       case (m, idx) =>
         val branchNs   = q"${csTypeInfo.adtNsName(a.id)}"
@@ -209,7 +176,7 @@ class ScUEBACodecGenerator(
         val encBody = if (target.language.wrappedAdtBranchCodecs) {
           q"""$cName.instance.encode(ctx, writer, $castedName)"""
         } else {
-          q"""writer.writeByte(${idx.toString});
+          q"""writer.writeByte(${idx.toString})
              |$cName.instance.encode(ctx, writer, $castedName)
            """.stripMargin
         }
@@ -221,32 +188,31 @@ class ScUEBACodecGenerator(
         }
 
         (
-          q"""if (value.isInstanceOf[$fqBranch])
-             |{   
-             |  val $castedName = value.asInstanceOf[$fqBranch]
+          q"""case $castedName: $fqBranch => 
              |  ${encBody.shift(2).trim}
-             |  return;
-             |}""".stripMargin,
-          q"""if (asByte == ${idx.toString})
-             |{
+             |""".stripMargin,
+          q"""if (asByte == ${idx.toString}) {
              |  ${decBody.shift(2).trim}
              |}""".stripMargin,
         )
     }
 
     (
-      q"""${branches.map(_._1).join("\n")}
+      q"""value match {
+         |  ${branches.map(_._1).joinN().shift(2).trim}
          |
-         |throw new $genericException(s"Cannot encode {value} to ${name.name}: no matching value")""".stripMargin,
+         |  case _ => throw new $genericException(s"Cannot encode {value} to ${name.name}: no matching value")
+         |}
+         |""".stripMargin,
       q"""val asByte = wire.readByte();
          |
-         |${branches.map(_._2).join("\n")}
+         |${branches.map(_._2).joinN()}
          |
          |throw new $genericException(s"Cannot decode {wire} to ${name.name}: no matching value")""".stripMargin,
     )
   }
 
-  private def genEnumBodies(name: ScValue.ScType, e: Typedef.Enum) = {
+  private def genEnumBodies(name: ScValue.ScType, e: Typedef.Enum): (TextTree[ScValue.ScType], TextTree[ScValue.ScType]) = {
     val branches = e.members.zipWithIndex.toList.map {
       case (m, idx) =>
         (
@@ -263,12 +229,12 @@ class ScUEBACodecGenerator(
     }
 
     (
-      q"""${branches.map(_._1).join("\n")}
+      q"""${branches.map(_._1).joinN()}
          |
          |throw new $genericException(s"Cannot encode {value} to ${name.name}: no matching value")""".stripMargin,
       q"""val asByte = wire.readByte()
          |
-         |${branches.map(_._2).join("\n")}
+         |${branches.map(_._2).joinN()}
          |
          |throw new $genericException(s"Cannot decode {wire} to ${name.name}: no matching value")""".stripMargin,
     )
@@ -294,7 +260,7 @@ class ScUEBACodecGenerator(
     val noIndex = Seq(
       q"writer.writeByte(header.toInt)",
       fields.map(_._1).joinN(),
-    ).filterNot(_.isEmpty).join("\n")
+    ).filterNot(_.isEmpty).joinN()
 
     val fenc =
       q"""var header: $scByte = 0b0000000;
@@ -307,7 +273,7 @@ class ScUEBACodecGenerator(
          |  try  {
          |    val fakeWriter = new $binaryOutput(writeMemoryStream)
          |    try {
-         |      ${fields.map(_._3).join("\n").shift(6).trim}
+         |      ${fields.map(_._3).joinN().shift(6).trim}
          |    } finally {
          |      fakeWriter.close()
          |    }
@@ -415,7 +381,7 @@ class ScUEBACodecGenerator(
                |  val after = writeMemoryStream.size()
                |  val length = after - before
                |  writer.writeInt(length)
-               |  ${sanityChecks.shift(2).trim};
+               |  ${sanityChecks.shift(2).trim}
                |}""".stripMargin
         }
 
@@ -546,16 +512,27 @@ class ScUEBACodecGenerator(
     }
   }
 
+  private def renderMeta(defn: DomainMember.User, meta: List[MetaField]): List[TextTree[ScValue]] = {
+    defn.defn match {
+      case _: Typedef.Enum | _: Typedef.Foreign => meta.map(_.valueField)
+      case _                                    => meta.map(_.refValueField)
+    }
+  }
+
   def codecName(name: ScValue.ScType): ScValue.ScType = {
     ScValue.ScType(name.pkg, s"${name.name}_UEBACodec", name.fq)
   }
 
-  override def codecMeta(defn: DomainMember.User, name: ScValue.ScType): scl.ScCodecTranslator.CodecMeta = {
-    CodecMeta(
-      q"""public $baboonBinCodec[$name] Codec_UEBA()
-         |{
-         |  return ${codecName(name)}.instance
-         |}""".stripMargin
-    )
+  override def codecMeta(defn: DomainMember.User, name: ScValue.ScType): Option[CodecMeta] = {
+    if (isActive(defn.id)) {
+      Some(CodecMeta(q"def codecUeba: $baboonBinCodec[$name] = ${codecName(name)}.instance"))
+    } else None
   }
+
+  override def isActive(id: TypeId): Boolean = {
+    target.language.generateUebaCodecs && (target.language.generateUebaCodecsByDefault || domain.derivationRequests
+      .getOrElse(DerivationDecl("ueba"), Set.empty[TypeId]).contains(id))
+  }
+
+  override def id: String = "Ueba"
 }
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScValue.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScValue.scala
index b0438580..0834d20b 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScValue.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScValue.scala
@@ -13,7 +13,7 @@ object ScValue {
       ScPackageId(NEList.unsafeFrom(pkg.split('.').toList))
   }
 
-  case class ScType(pkg: ScValue.ScPackageId, name: String, fq: Boolean = false) extends ScValue {
+  case class ScType(pkg: ScValue.ScPackageId, name: String, fq: Boolean = false, predef: Boolean = false) extends ScValue {
     def fullyQualified: ScType = this.copy(fq = true)
     def asName: ScTypeName     = ScTypeName(name)
 
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/typer/model/DomainMember.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/typer/model/DomainMember.scala
index 18805544..911ce9ca 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/typer/model/DomainMember.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/typer/model/DomainMember.scala
@@ -11,5 +11,11 @@ object DomainMember {
 
   case class User(root: Boolean, defn: Typedef.User, derivations: Set[DerivationDecl], meta: RawNodeMeta) extends DomainMember {
     def id: TypeId.User = defn.id
+    def isAdt: Boolean = {
+      defn.id.owner match {
+        case _: Owner.Adt => true
+        case _            => false
+      }
+    }
   }
 }

From 479f6feffabe4b3623bb15006b7719293f9c4f24 Mon Sep 17 00:00:00 2001
From: nikita-ty754 <nikitatishchenko1@gmail.com>
Date: Mon, 15 Dec 2025 11:00:06 +0200
Subject: [PATCH 2/6] Codecs: decode wrapped in either

---
 .../baboon-runtime/scala/BaboonCodecs.scala   |  99 ++++--
 .../scala/BaboonCodecsFacade.scala            |  19 +-
 .../baboon-runtime/scala/BaboonTools.scala    |   5 +-
 .../io/septimalmind/baboon/BaboonModule.scala |  12 +-
 .../translator/scl/ScBaboonTranslator.scala   |   4 +-
 .../scl/ScCodecFixtureTranslator.scala        |  12 +-
 .../scl/ScCodecTestsTranslator.scala          |   4 +-
 .../scl/ScConversionTranslator.scala          |  41 +--
 .../translator/scl/ScDomainTreeTools.scala    |   2 +-
 .../baboon/translator/scl/ScFileTools.scala   |  12 +-
 .../translator/scl/ScJsonCodecGenerator.scala | 321 ++++++++----------
 .../baboon/translator/scl/ScTypeInfo.scala    |   9 -
 .../translator/scl/ScTypeTranslator.scala     |  14 +-
 .../baboon/translator/scl/ScTypes.scala       |  79 ++++-
 .../translator/scl/ScUEBACodecGenerator.scala | 137 ++++----
 15 files changed, 401 insertions(+), 369 deletions(-)
 delete mode 100644 baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeInfo.scala

diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecs.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecs.scala
index 997e9d63..3bfba465 100644
--- a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecs.scala
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecs.scala
@@ -1,11 +1,14 @@
 package baboon.runtime.shared {
 
-  import io.circe.Json
+  import io.circe.numbers.BiggerDecimal
+  import io.circe.{Decoder, Json, JsonObject, KeyDecoder}
 
   import java.io.*
   import java.nio.{ByteBuffer, ByteOrder}
+  import java.time.OffsetDateTime
   import scala.collection.mutable
   import scala.reflect.ClassTag
+  import scala.util.Try
 
   trait BaboonCodecData {
     def baboonDomainVersion: String
@@ -32,16 +35,39 @@ package baboon.runtime.shared {
 
   trait BaboonValueCodec[T, TWire] extends BaboonCodec[T] {
     def encode(ctx: BaboonCodecContext, instance: T): TWire
-    def decode(ctx: BaboonCodecContext, wire: TWire): Either[String, T]
+    def decode(ctx: BaboonCodecContext, wire: TWire): Either[Throwable, T]
   }
   trait BaboonStreamCodec[T, TOut, TIn] extends BaboonCodec[T] {
     def encode(ctx: BaboonCodecContext, writer: TOut, instance: T): Unit
-    def decode(ctx: BaboonCodecContext, wire: TIn): T
+    def decode(ctx: BaboonCodecContext, wire: TIn): Either[Throwable, T]
   }
 
-  trait BaboonJsonCodec[T] extends BaboonValueCodec[T, Json]
+  trait BaboonJsonCodec[T] extends BaboonValueCodec[T, Json] {
+    protected final def getField(jsonObject: JsonObject, name: String): Either[Exception, Json] = {
+      jsonObject(name).toRight(new RuntimeException(s"Cannot decode $jsonObject to $baboonTypeIdentifier: missing fields $name"))
+    }
+
+    final def circeDecoder: Decoder[T] = {
+      Decoder.instanceTry(cursor => this.decode(BaboonCodecContext.Compact, cursor.value).toTry)
+    }
+  }
 
   object BaboonJsonCodec {
+    val decodeTsu: Decoder[OffsetDateTime]    = Decoder.instanceTry(cursor => cursor.as[String].toTry.flatMap(BaboonTimeFormats.parseTsu))
+    val decodeTso: Decoder[OffsetDateTime]    = Decoder.instanceTry(cursor => cursor.as[String].toTry.flatMap(BaboonTimeFormats.parseTso))
+    val decodeByteString: Decoder[ByteString] = Decoder.instanceTry(cursor => cursor.as[String].toTry.flatMap(ByteString.tryParse))
+    val decodeByte: Decoder[Byte]             = Decoder.instance(cursor => Decoder.decodeLong(cursor).map(_.toByte))
+    val decodeShort: Decoder[Short]           = Decoder.instance(cursor => Decoder.decodeLong(cursor).map(_.toShort))
+    val decodeInt: Decoder[Int]               = Decoder.instance(cursor => Decoder.decodeLong(cursor).map(_.toInt))
+    val decodeLong: Decoder[Long]             = Decoder.instance(cursor => Decoder.decodeBigInt(cursor).map(_.longValue))
+
+    val decodeKeyBoolean: KeyDecoder[Boolean]        = _.toBooleanOption
+    val decodeKeyFloat: KeyDecoder[Float]            = _.toFloatOption
+    val keyDecoderBigDecimal: KeyDecoder[BigDecimal] = KeyDecoder.instance(s => BiggerDecimal.parseBiggerDecimal(s).flatMap(_.toBigDecimal).map(new BigDecimal(_)))
+    val decodeKeyTso: KeyDecoder[OffsetDateTime]     = BaboonTimeFormats.parseTso(_).toOption
+    val decodeKeyTsu: KeyDecoder[OffsetDateTime]     = BaboonTimeFormats.parseTsu(_).toOption
+    val decodeKeyByteString: KeyDecoder[ByteString]  = ByteString.tryParse(_).toOption
+
     trait BaboonGeneratedJsonCodec[T <: BaboonGenerated, TCodec <: BaboonJsonCodec[T]] {
       self: Base[T, TCodec] =>
       final def encode(ctx: BaboonCodecContext, instance: BaboonGenerated)(implicit t: ClassTag[T]): Json = {
@@ -57,25 +83,28 @@ package baboon.runtime.shared {
     trait NoEncoder[T, TCodec <: BaboonJsonCodec[T]] extends Base[T, TCodec] {
       override def encode(ctx: BaboonCodecContext, instance: T): Json = {
         if (this ne LazyInstance.value) {
-          return LazyInstance.value.encode(ctx, instance)
+          LazyInstance.value.encode(ctx, instance)
+        } else {
+          throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
         }
-        throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
       }
     }
     trait NoEncoderGenerated[T <: BaboonGenerated, TCodec <: BaboonJsonCodec[T]] extends BaseGenerated[T, TCodec] {
       override def encode(ctx: BaboonCodecContext, instance: T): Json = {
         if (this ne LazyInstance.value) {
-          return LazyInstance.value.encode(ctx, instance)
+          LazyInstance.value.encode(ctx, instance)
+        } else {
+          throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
         }
-        throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
       }
     }
     trait NoEncoderGeneratedAdt[T <: BaboonGenerated, TCodec <: BaboonJsonCodec[T]] extends BaseGeneratedAdt[T, TCodec] {
       override def encode(ctx: BaboonCodecContext, instance: T): Json = {
         if (this ne LazyInstance.value) {
-          return LazyInstance.value.encode(ctx, instance)
+          LazyInstance.value.encode(ctx, instance)
+        } else {
+          throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
         }
-        throw new RuntimeException(s"Type $baboonTypeIdentifier@$baboonDomainVersion is deprecated, encoder was not generated")
       }
     }
   }
@@ -126,37 +155,37 @@ package baboon.runtime.shared {
   trait BaboonBinCodecIndexed {
     def indexElementsCount(ctx: BaboonCodecContext): Short
 
-    def readIndex(ctx: BaboonCodecContext, wire: LEDataInputStream): List[BaboonIndexEntry] = {
-      val header           = wire.readByte()
-      val isIndexed        = (header & 0x01) != 0
-      val result           = scala.collection.mutable.ListBuffer.empty[BaboonIndexEntry]
-      var prevOffset: Long = 0L
-      var prevLen: Long    = 0L
-
-      if (isIndexed) {
-        var left = indexElementsCount(ctx).toInt
-        while (left > 0) {
-          val offset = wire.readInt()
-          val len    = wire.readInt()
-
-          require(len > 0, "Length must be positive")
-          require(offset >= prevOffset + prevLen, s"Offset violation: $offset not >= ${prevOffset + prevLen}")
-
-          result += BaboonIndexEntry(offset.toLong, len.toLong)
-          left       = left - 1
-          prevOffset = offset.toLong
-          prevLen    = len.toLong
+    def readIndex(ctx: BaboonCodecContext, wire: LEDataInputStream): Either[Throwable, List[BaboonIndexEntry]] = {
+      Try {
+        val header           = wire.readByte()
+        val isIndexed        = (header & 0x01) != 0
+        val result           = scala.collection.mutable.ListBuffer.empty[BaboonIndexEntry]
+        var prevOffset: Long = 0L
+        var prevLen: Long    = 0L
+        if (isIndexed) {
+          var left = indexElementsCount(ctx).toInt
+          while (left > 0) {
+            val offset = wire.readInt()
+            val len    = wire.readInt()
+
+            require(len > 0, "Length must be positive")
+            require(offset >= prevOffset + prevLen, s"Offset violation: $offset not >= ${prevOffset + prevLen}")
+
+            result += BaboonIndexEntry(offset.toLong, len.toLong)
+            left       = left - 1
+            prevOffset = offset.toLong
+            prevLen    = len.toLong
+          }
         }
-      }
-
-      result.toList
+        result.toList
+      }.toEither
     }
   }
 
   trait AbstractBaboonCodecs {
     private val registry = mutable.Map.empty[String, Lazy[BaboonCodecData]]
 
-    def register[T](id: String, codec: Lazy[BaboonCodecData]): Unit = {
+    def register(id: String, codec: Lazy[BaboonCodecData]): Unit = {
       registry.put(id, codec)
     }
 
@@ -346,4 +375,4 @@ package baboon.runtime.shared {
     @throws[IOException]
     override def writeUTF(s: String): Unit = dataOut.writeUTF(s)
   }
-}
\ No newline at end of file
+}
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecsFacade.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecsFacade.scala
index 5769af1b..52634a6e 100644
--- a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecsFacade.scala
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonCodecsFacade.scala
@@ -173,13 +173,14 @@ package baboon.runtime.shared {
           .toRight(BaboonCodecException.DecoderFailure("Cannot decode binary type meta"))
 
         codec <- getBinCodec(typeMeta, exact = false)
-        baboon <- Try(codec.decode(BaboonCodecContext.Compact, reader)).toEither.left.map(
-          e =>
-            BaboonCodecException.DecoderFailure(
-              s"Can not decode BIN form type [${typeMeta.domainIdentifier}.${typeMeta.typeIdentifier}] of version '${typeMeta.domainVersion}'.",
-              e,
-            )
-        )
+        baboon <- codec
+          .decode(BaboonCodecContext.Compact, reader).left.map(
+            e =>
+              BaboonCodecException.DecoderFailure(
+                s"Can not decode BIN form type [${typeMeta.domainIdentifier}.${typeMeta.typeIdentifier}] of version '${typeMeta.domainVersion}'.",
+                e,
+              )
+          )
       } yield baboon
     }
 
@@ -235,10 +236,6 @@ package baboon.runtime.shared {
       val maybeContentToken = value.hcursor.downField(CONTENT_JSON_KEY).as[Json].toOption
       (maybeTypeMeta, maybeContentToken) match {
         case (Some(typeMeta), Some(contentToken)) =>
-          for {
-            jsonCodec <- getJsonCodec(typeMeta, exact = false)
-            baboon    <- jsonCodec.decode(BaboonCodecContext.Compact, contentToken)
-          } yield baboon
           Try(getJsonCodec(typeMeta, exact = false).flatMap(_.decode(BaboonCodecContext.Compact, contentToken))).toEither.left
             .map(
               e =>
diff --git a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonTools.scala b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonTools.scala
index dcaf89f4..ca8765a0 100644
--- a/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonTools.scala
+++ b/baboon-compiler/src/main/resources/baboon-runtime/scala/BaboonTools.scala
@@ -5,6 +5,7 @@ package baboon.runtime.shared {
   import java.time.format.DateTimeFormatter
   import java.time.{Instant, OffsetDateTime, ZoneOffset}
   import java.util.UUID
+  import scala.util.Try
 
   object BaboonTimeFormats {
 
@@ -13,8 +14,8 @@ package baboon.runtime.shared {
     val tsuFormat: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX")
     val tsoFormat: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX")
 
-    def parseTso(s: String): Option[OffsetDateTime] = Some(OffsetDateTime.parse(s, tsoFormat))
-    def parseTsu(s: String): Option[OffsetDateTime] = Some(OffsetDateTime.parse(s, tsuFormat))
+    def parseTso(s: String): Try[OffsetDateTime] = Try(OffsetDateTime.parse(s, tsoFormat))
+    def parseTsu(s: String): Try[OffsetDateTime] = Try(OffsetDateTime.parse(s, tsuFormat))
 
     def formatTsu(s: OffsetDateTime): String = s.format(tsuFormat)
     def formatTso(s: OffsetDateTime): String = s.format(tsoFormat)
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/BaboonModule.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/BaboonModule.scala
index 6c0d279f..3665a264 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/BaboonModule.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/BaboonModule.scala
@@ -1,6 +1,7 @@
 package io.septimalmind.baboon
 
-import distage.{DIKey, ModuleDef}
+import distage.DIKey
+import distage.ModuleDef
 import io.septimalmind.baboon.parser.BaboonParser
 import io.septimalmind.baboon.translator.BaboonAbstractTranslator
 import io.septimalmind.baboon.translator.csharp.*
@@ -11,7 +12,13 @@ import io.septimalmind.baboon.typer.model.*
 import io.septimalmind.baboon.util.BaboonMetagen
 import io.septimalmind.baboon.validator.BaboonValidator
 import izumi.functional.bio.unsafe.MaybeSuspend2
-import izumi.functional.bio.{Applicative2, ApplicativeError2, Bifunctor2, Error2, Guarantee2, Monad2, ParallelErrorAccumulatingOps2}
+import izumi.functional.bio.Applicative2
+import izumi.functional.bio.ApplicativeError2
+import izumi.functional.bio.Bifunctor2
+import izumi.functional.bio.Error2
+import izumi.functional.bio.Guarantee2
+import izumi.functional.bio.Monad2
+import izumi.functional.bio.ParallelErrorAccumulatingOps2
 import izumi.reflect.TagKK
 
 class BaboonSharedModule[F[+_, +_]: Error2: MaybeSuspend2: TagKK] extends ModuleDef {
@@ -100,7 +107,6 @@ class BaboonCommonScModule[F[+_, +_]: Error2: TagKK]() extends ModuleDef {
   make[ScTreeTools].from[ScTreeTools.ScTreeToolsImpl]
 
   make[ScTypeTranslator]
-  make[ScTypeInfo]
   makeFactory[ScConversionTranslator.Factory[F]]
 
   make[ScBaboonTranslator[F]].aliased[BaboonAbstractTranslator[F]]
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScBaboonTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScBaboonTranslator.scala
index fd5bf9d6..756ca7b5 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScBaboonTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScBaboonTranslator.scala
@@ -60,7 +60,7 @@ class ScBaboonTranslator[F[+_, +_]: Error2](
   private def translateProduct(
     domain: Domain,
     p: CompilerProduct,
-    translate: (DomainMember.User) => F[NEList[BaboonIssue], List[ScDefnTranslator.Output]],
+    translate: DomainMember.User => F[NEList[BaboonIssue], List[ScDefnTranslator.Output]],
   ): F[NEList[BaboonIssue], List[ScDefnTranslator.Output]] = {
     if (target.output.products.contains(p)) {
       F.flatTraverseAccumErrors(domain.defs.meta.nodes.toList) {
@@ -233,7 +233,7 @@ class ScBaboonTranslator[F[+_, +_]: Error2](
                   domain = domain,
                   rules  = rules,
                   evo    = lineage.evolution,
-                ).makeConvs()
+                ).makeConvs
             }
         }
     } yield {
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecFixtureTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecFixtureTranslator.scala
index 144a3dc0..25e15c2c 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecFixtureTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecFixtureTranslator.scala
@@ -48,8 +48,7 @@ object ScCodecFixtureTranslator {
               } yield {
                 q"$oid.$did"
               }
-            case _ =>
-              defnFixtureId(definition)
+            case _ => defnFixtureId(definition)
           }
       }
 
@@ -91,21 +90,22 @@ object ScCodecFixtureTranslator {
     }
 
     private def doTranslateAdt(adt: Typedef.Adt): TextTree[ScValue] = {
+      val adtName = adt.id.name.name
       val members = adt.members.toList
-        .flatMap(m => domain.defs.meta.nodes.get(m))
+        .flatMap(domain.defs.meta.nodes.get)
         .collect { case DomainMember.User(_, d: Typedef.Dto, _, _) => d }
 
-      val membersFixtures   = members.sortBy(_.id.toString).map(dto => doTranslateDto(dto))
+      val membersFixtures   = members.sortBy(_.id.toString).map(doTranslateDto)
       val membersGenerators = members.sortBy(_.id.toString).map(dto => q"${dto.id.name.name}_Fixture.random")
 
       q"""object ${fixtureTpe(adt.id)} {
-         |  def random(rnd: $baboonRandom): ${adt.id.name.name} = {
+         |  def random(rnd: $baboonRandom): $adtName = {
          |    rnd.oneOf($scList(
          |      ${membersGenerators.join(",\n").shift(6).trim}
          |    ))
          |  }
          |
-         |  def randomAll(rnd: $baboonRandom): $scList[${adt.id.name.name}] = {
+         |  def randomAll(rnd: $baboonRandom): $scList[$adtName] = {
          |    $scList(
          |      ${membersGenerators.map(g => q"$g(rnd)").join(",\n").shift(6).trim}
          |    )
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala
index 118dc57b..28e2b487 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala
@@ -120,7 +120,7 @@ object ScCodecTestsTranslator {
              |  val csUebaBytes = $javaNioFiles.readAllBytes(f.toPath)
              |  val bais = new java.io.ByteArrayInputStream(csUebaBytes)
              |  val dis = new $binaryInput(bais)
-             |  val dec = $codecName.instance.decode(context, dis)
+             |  val dec = $codecName.instance.decode(context, dis).toOption.get
              |  val sclUebaBytes = uebaCompare(context, dec, clue)
              |  assert(csUebaBytes.length == sclUebaBytes.length, s"$$clue")
              |}
@@ -134,7 +134,7 @@ object ScCodecTestsTranslator {
              |  
              |  val bais = new java.io.ByteArrayInputStream(bytes)
              |  val dis = new $binaryInput(bais)
-             |  val dec = $codecName.instance.decode(context, dis)
+             |  val dec = $codecName.instance.decode(context, dis).toOption.get
              |  assert(fixture == dec, s"$$clue")
              |  
              |  bytes
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScConversionTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScConversionTranslator.scala
index 90c32f03..1abc6fb5 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScConversionTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScConversionTranslator.scala
@@ -101,29 +101,24 @@ class ScConversionTranslator[F[+_, +_]: Error2](
     s: TypeRef.Scalar,
     os: TypeRef.Scalar,
   ): TextTree[ScValue] = {
-    val direct = if (s == os) {
-      oldRef
-    } else {
-      q"($oldRef.asInstanceOf[$newTypeRefTree])"
-    }
+    val direct =
+      if (s == os) oldRef
+      else q"($oldRef.asInstanceOf[$newTypeRefTree])"
 
     val conv =
       q"conversions.convertWithContext[C, $oldTypeRefTree, $newTypeRefTree](context, $oldRef)"
 
     s.id match {
-      case _: TypeId.Builtin =>
-        direct
+      case _: TypeId.Builtin => direct
       case id: TypeId.User =>
         domain.defs.meta.nodes(id) match {
-          case DomainMember.User(_, _: Typedef.Foreign, _, _) =>
-            direct
-          case _ =>
-            conv
+          case DomainMember.User(_, _: Typedef.Foreign, _, _) => direct
+          case _                                              => conv
         }
     }
   }
 
-  def makeConvs(): Out[List[RenderedConversion]] = {
+  def makeConvs: Out[List[RenderedConversion]] = {
     def makeName(prefix: String, conv: Conversion): String =
       (Seq(prefix) ++ conv.sourceTpe.owner.asPseudoPkg ++ Seq(
         conv.sourceTpe.name.name,
@@ -141,9 +136,9 @@ class ScConversionTranslator[F[+_, +_]: Error2](
         val tin  = trans.asScType(conv.sourceTpe, srcDom, evo).fullyQualified
         def tout = trans.asScType(conv.sourceTpe, domain, evo)
 
-        val meta = q"""override def versionFrom: String = "${srcVer.v.toString}"
-                      |override def versionTo: String = "${domain.version.v.toString}"
-                      |override def typeId: String = "${conv.sourceTpe.toString}"
+        val meta = q"""override def versionFrom: $scString = "${srcVer.v.toString}"
+                      |override def versionTo: $scString = "${domain.version.v.toString}"
+                      |override def typeId: $scString = "${conv.sourceTpe.toString}"
                       """.stripMargin.trim
 
         val rendered = conv match {
@@ -151,7 +146,7 @@ class ScConversionTranslator[F[+_, +_]: Error2](
             val classDef = q"""|abstract class $className
                                |  extends $baboonAbstractConversion[$tin, $tout] {
                                |    def doConvert[C](
-                               |      context: Option[C],
+                               |      context: $scOption[C],
                                |      conversions: $baboonAbstractConversions,
                                |      from: $tin
                                |    ): $tout
@@ -170,16 +165,14 @@ class ScConversionTranslator[F[+_, +_]: Error2](
               )
             )
 
-          case _: Conversion.RemovedTypeNoConversion =>
-            Nil
-          case _: Conversion.NonDataTypeTypeNoConversion =>
-            Nil
+          case _: Conversion.RemovedTypeNoConversion     => Nil
+          case _: Conversion.NonDataTypeTypeNoConversion => Nil
 
           case _: Conversion.CopyEnumByName =>
             val classDef = q"""|object $className
                                |  extends $baboonAbstractConversion[$tin, $tout] {
                                |    override def doConvert[C](
-                               |      context: Option[C],
+                               |      context: $scOption[C],
                                |      conversions: $baboonAbstractConversions,
                                |      from: $tin
                                |    ): $tout = $tout.parse(from.toString).get
@@ -194,13 +187,13 @@ class ScConversionTranslator[F[+_, +_]: Error2](
               oldId =>
                 val oldT = trans.asScType(oldId, srcDom, evo).fullyQualified
                 q"case x: $oldT => ${transfer(TypeRef.Scalar(oldId), q"x", 1)}"
-            } :+ q"case other => throw new IllegalArgumentException(s\"Bad input: $$other\")"
+            } :+ q"case other => throw new $javaIllegalArgumentException(s\"Bad input: $$other\")"
 
             val classDef = q"""
                               |object $className
                               |  extends $baboonAbstractConversion[$tin, $tout] {
                               |    override def doConvert[C](
-                              |      context: Option[C],
+                              |      context: $scOption[C],
                               |      conversions: $baboonAbstractConversions,
                               |      from: $tin
                               |    ): $tout = from match {
@@ -252,7 +245,7 @@ class ScConversionTranslator[F[+_, +_]: Error2](
                               |object $className
                               |  extends $baboonAbstractConversion[$tin, $tout] {
                               |    override def doConvert[C](
-                              |      context: Option[C],
+                              |      context: $scOption[C],
                               |      conversions: $baboonAbstractConversions,
                               |      _from: $tin
                               |    ): $tout = {
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDomainTreeTools.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDomainTreeTools.scala
index c190753d..14276360 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDomainTreeTools.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScDomainTreeTools.scala
@@ -78,7 +78,7 @@ object ScDomainTreeTools {
       val unmodifiedSince = evolution.typesUnchangedSince(domain.version)(defn.id).sameIn.map(v => s"\"${v.v.toString}\"")
       val sameInVersion = MetaField(
         q"def baboonSameInVersions: $scList[$scString]",
-        q"List(${unmodifiedSince.mkString(", ")})",
+        q"$scList(${unmodifiedSince.mkString(", ")})",
         q"$ref.baboonSameInVersions",
       )
       List(sameInVersion)
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScFileTools.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScFileTools.scala
index 33aab675..c7fd75ed 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScFileTools.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScFileTools.scala
@@ -7,7 +7,7 @@ trait ScFileTools {
 }
 
 object ScFileTools {
-  class ScFileToolsImpl() extends ScFileTools {
+  class ScFileToolsImpl extends ScFileTools {
     def basename(dom: Domain, evolution: BaboonEvolution): String = {
       basename(
         dom,
@@ -17,14 +17,10 @@ object ScFileTools {
 
     private def basename(dom: Domain, omitVersion: Boolean): String = {
       val base = dom.id.path.map(_.toLowerCase)
-      val segments = if (omitVersion) {
-        base
-      } else {
-        base ++ Seq(dom.version.v.toString)
-      }
-
+      val segments =
+        if (omitVersion) base
+        else base ++ Seq(dom.version.v.toString)
       segments.mkString("/")
     }
-
   }
 }
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala
index 6601efdd..00403c99 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala
@@ -14,7 +14,6 @@ class ScJsonCodecGenerator(
   target: ScTarget,
   domain: Domain,
   evo: BaboonEvolution,
-  scTypeInfo: ScTypeInfo,
   scDomainTreeTools: ScDomainTreeTools,
 ) extends ScCodecTranslator {
 
@@ -55,7 +54,6 @@ class ScJsonCodecGenerator(
       }
     } else None
   }
-
   private def genCodec(
     defn: DomainMember.User,
     name: ScValue.ScType,
@@ -68,7 +66,7 @@ class ScJsonCodecGenerator(
     val encodeMethod =
       if (isEncoderEnabled) {
         List(
-          q"""def encode(ctx: $baboonCodecContext, value: $name): io.circe.Json = {
+          q"""def encode(ctx: $baboonCodecContext, value: $name): $circeJson = {
              |  ${enc.shift(2).trim}
              |}
              |""".stripMargin.trim
@@ -76,7 +74,7 @@ class ScJsonCodecGenerator(
       } else Nil
     val decodeMethod =
       List(
-        q"""def decode(ctx: $baboonCodecContext, wire: io.circe.Json): Either[String, $name] = {
+        q"""def decode(ctx: $baboonCodecContext, wire: $circeJson): $scEither[$javaThrowable, $name] = {
            |  ${dec.shift(2).trim}
            |}""".stripMargin.trim
       )
@@ -111,12 +109,10 @@ class ScJsonCodecGenerator(
        |""".stripMargin
   }
 
-  private def genForeignBodies(
-    name: ScValue.ScType
-  ): (TextTree[Nothing], TextTree[Nothing]) = {
+  private def genForeignBodies(name: ScValue.ScType): (TextTree[ScValue], TextTree[ScValue]) = {
     (
-      q"""throw new IllegalArgumentException(s"${name.name} is a foreign type")""",
-      q"""throw new IllegalArgumentException(s"${name.name} is a foreign type")""",
+      q"""throw new $javaIllegalArgumentException(s"${name.name} is a foreign type")""",
+      q"""throw new $javaIllegalArgumentException(s"${name.name} is a foreign type")""",
     )
   }
 
@@ -124,13 +120,13 @@ class ScJsonCodecGenerator(
     branchName: String,
     tree: TextTree[ScValue],
   ): TextTree[ScValue] = {
-    q"""io.circe.Json.obj("$branchName" -> $tree)"""
+    q"""$circeJson.obj("$branchName" -> $tree)"""
   }
 
-  private def genAdtBodies(name: ScValue.ScType, a: Typedef.Adt): (TextTree[ScValue], TextTree[Nothing]) = {
-    val branches = a.dataMembers(domain).map {
+  private def genAdtBodies(name: ScValue.ScType, adt: Typedef.Adt): (TextTree[ScValue], TextTree[ScValue]) = {
+    val branches = adt.dataMembers(domain).map {
       m =>
-        val branchNs            = q"${scTypeInfo.adtNsName(a.id)}"
+        val branchNs            = q"${adt.id.name.name}"
         val branchName          = m.name.name
         val fqBranch            = q"$branchNs.$branchName"
         val branchNameRef       = q"${branchName.toLowerCase}"
@@ -142,11 +138,10 @@ class ScJsonCodecGenerator(
           wrapAdtBranchEncoder(branchName, routedBranchEncoder)
         }
 
-        val branchValue = if (target.language.wrappedAdtBranchCodecs) q"wire" else q"head._2"
+        val branchValue = if (target.language.wrappedAdtBranchCodecs) q"wire" else q"json"
 
         (
-          q"""case $branchNameRef: $fqBranch => 
-             |  $branchEncoder
+          q"""case $branchNameRef: $fqBranch => $branchEncoder
              |""".stripMargin,
           q"""case "$branchName" =>
              |  ${fqBranch}_JsonCodec.instance.decode(ctx, $branchValue)
@@ -158,39 +153,37 @@ class ScJsonCodecGenerator(
     (
       q"""value match {
          |  ${branches.map(_._1).joinN().shift(2).trim}
-         |  
-         |  case _ => throw new IllegalArgumentException(s"Cannot encode $$value: unexpected subclass")
-         |}
-         |
          |
-         |""".stripMargin,
-      q"""val asObject = wire.asObject
-         |if (asObject.isEmpty) {
-         |  throw new IllegalArgumentException(s"Cannot decode $$wire to ${name.name}: object expected")
+         |  case _ => throw new $javaIllegalArgumentException(s"Cannot encode $$value: unexpected subclass")
          |}
-         |val head = asObject.get.toList.head
-         |
-         |head._1 match {
-         |  ${branches.map(_._2).joinN().shift(2).trim}
+         |""".stripMargin,
+      q"""wire.asObject match {
+         |  case Some(jsonObject) =>
+         |    jsonObject.toList.headOption match {
+         |      case Some((key, json)) =>
+         |        key match {
+         |          ${branches.map(_._2).joinN().shift(10).trim}
          |
-         |  case _ =>  throw new IllegalArgumentException(s"Cannot decode $$wire to ${name.name}: no matching value")
+         |          case _ => Left(new $javaIllegalArgumentException(s"Cannot decode $$wire to ${name.name}: no matching value"))
+         |        }
+         |      case _ => Left(new $javaIllegalArgumentException(s"Cannot decode $$wire to ${name.name}: empty json object"))
+         |    }
+         |  case _ => Left(new $javaIllegalArgumentException(s"Cannot decode $$wire to ${name.name}: object expected"))
          |}
          |""".stripMargin,
     )
   }
 
-  private def genEnumBodies(
-    name: ScValue.ScType
-  ): (TextTree[ScValue.ScType], TextTree[ScValue.ScType]) = {
+  private def genEnumBodies(name: ScValue.ScType): (TextTree[ScValue.ScType], TextTree[ScValue.ScType]) = {
     (
-      q"""io.circe.Json.fromString(value.toString)""",
+      q"""$circeJson.fromString(value.toString)""",
       q"""wire.asString match {
          |  case Some(str) =>
          |    $name.parse(str.trim) match {
          |      case Some(result) => Right(result)
-         |      case None => Left(s"Cannot decode $$wire to ${name.name}: no matching value")
+         |      case None => Left(new $javaIllegalArgumentException(s"Cannot decode $$wire to ${name.name}: no matching value"))
          |    }
-         |  case None => Left(s"Cannot decode $$wire to ${name.name}: string expected")
+         |  case None => Left(new $javaIllegalArgumentException(s"Cannot decode $$wire to ${name.name}: string expected"))
          |}
          |""".stripMargin,
     )
@@ -201,14 +194,14 @@ class ScJsonCodecGenerator(
       f =>
         val fieldRef = q"value.${f.name.name}"
         val enc      = mkEncoder(f.tpe, fieldRef)
-        val dec      = mkDecoder(f.tpe, q"""asObject("${f.name.name}")""")
+        val dec      = decoder(f.name.name, f.tpe, q"jsonObject")
         (
           q""""${f.name.name}" -> $enc""",
-          q"${f.name.name} = $dec",
+          q"${f.name.name} <- $dec",
         )
     }
 
-    val mainEnc = q"""io.circe.Json.obj(
+    val mainEnc = q"""$circeJson.obj(
                      |  ${fields.map(_._1).join(",\n").shift(2).trim}
                      |)""".stripMargin
 
@@ -217,17 +210,19 @@ class ScJsonCodecGenerator(
       case _                                                      => mainEnc
     }
 
-    val fullDec = d.id.owner match {
-      case Owner.Adt(_) if target.language.wrappedAdtBranchCodecs => q"wire.asObject.get.toList.head._2.asObject.get"
-      case _                                                      => q"wire.asObject.get"
-    }
+    val decoderForExpr =
+      if (d.fields.nonEmpty) {
+        q"""for {
+           |  ${fields.map(_._2).joinN().shift(2).trim}
+           |} yield $name(${d.fields.map(_.name.name).mkString(",")})
+           |""".stripMargin
+      } else q"Right($name())"
 
     val decBody =
-      q"""val asObject = $fullDec
-         |
-         |Right($name(
-         |  ${fields.map(_._2).join(",\n").shift(2).trim}
-         |))
+      q"""wire.asObject match {
+         |  case Some(jsonObject) => ${decoderForExpr.shift(4).trim}
+         |  case _ => Left(new $javaIllegalArgumentException("Cannot decode $$wire to ${name.name}: object expected"))
+         |}
          |""".stripMargin
 
     (encBody, decBody)
@@ -259,155 +254,141 @@ class ScJsonCodecGenerator(
     tpe match {
       case TypeRef.Scalar(id) =>
         id match {
-          case TypeId.Builtins.uid =>
-            q"""io.circe.Json.fromString($ref.toString())"""
-          case TypeId.Builtins.tsu =>
-            q"""io.circe.Json.fromString($baboonTimeFormats.formatTsu($ref))"""
-          case TypeId.Builtins.tso =>
-            q"""io.circe.Json.fromString($baboonTimeFormats.formatTso($ref))"""
-          case TypeId.Builtins.bit => q"""io.circe.Json.fromBoolean($ref)"""
-          case TypeId.Builtins.i08 => q"""io.circe.Json.fromInt($ref.toInt)"""
-          case TypeId.Builtins.i16 => q"""io.circe.Json.fromInt($ref.toInt)"""
-          case TypeId.Builtins.i32 => q"""io.circe.Json.fromInt($ref)"""
-
-          case TypeId.Builtins.i64 => q"""io.circe.Json.fromLong($ref)"""
-          case TypeId.Builtins.u08 => q"""io.circe.Json.fromInt(java.lang.Byte.toUnsignedInt($ref))"""
-          case TypeId.Builtins.u16 => q"""io.circe.Json.fromInt(java.lang.Short.toUnsignedInt($ref))"""
-          case TypeId.Builtins.u32 => q"""io.circe.Json.fromLong(java.lang.Integer.toUnsignedLong($ref))"""
-          case TypeId.Builtins.u64 => q"""io.circe.Json.fromBigInt($baboonBinTools.toUnsignedBigInt($ref))"""
-
-          case TypeId.Builtins.f32  => q"""io.circe.Json.fromFloat($ref).get"""
-          case TypeId.Builtins.f64  => q"""io.circe.Json.fromDouble($ref).get"""
-          case TypeId.Builtins.f128 => q"""io.circe.Json.fromBigDecimal($ref)"""
-
-          case TypeId.Builtins.str =>
-            q"""io.circe.Json.fromString($ref)"""
-          case TypeId.Builtins.bytes =>
-            q"""io.circe.Json.fromString($ref.toHexString)"""
+          case TypeId.Builtins.uid => q"$circeJson.fromString($ref.toString())"
+          case TypeId.Builtins.tsu => q"$circeJson.fromString($baboonTimeFormats.formatTsu($ref))"
+          case TypeId.Builtins.tso => q"$circeJson.fromString($baboonTimeFormats.formatTso($ref))"
+          case TypeId.Builtins.bit => q"$circeJson.fromBoolean($ref)"
+          case TypeId.Builtins.i08 => q"$circeJson.fromInt($ref.toInt)"
+          case TypeId.Builtins.i16 => q"$circeJson.fromInt($ref.toInt)"
+          case TypeId.Builtins.i32 => q"$circeJson.fromInt($ref)"
+
+          case TypeId.Builtins.i64 => q"$circeJson.fromLong($ref)"
+          case TypeId.Builtins.u08 => q"$circeJson.fromInt(java.lang.Byte.toUnsignedInt($ref))"
+          case TypeId.Builtins.u16 => q"$circeJson.fromInt(java.lang.Short.toUnsignedInt($ref))"
+          case TypeId.Builtins.u32 => q"$circeJson.fromLong(java.lang.Integer.toUnsignedLong($ref))"
+          case TypeId.Builtins.u64 => q"$circeJson.fromBigInt($baboonBinTools.toUnsignedBigInt($ref))"
+
+          case TypeId.Builtins.f32  => q"$circeJson.fromFloat($ref).get"
+          case TypeId.Builtins.f64  => q"$circeJson.fromDouble($ref).get"
+          case TypeId.Builtins.f128 => q"$circeJson.fromBigDecimal($ref)"
+
+          case TypeId.Builtins.str   => q"$circeJson.fromString($ref)"
+          case TypeId.Builtins.bytes => q"$circeJson.fromString($ref.toHexString)"
           case u: TypeId.User =>
             val targetTpe = codecName(trans.toScTypeRefKeepForeigns(u, domain, evo))
-            q"""$targetTpe.instance.encode(ctx, $ref)"""
+            q"$targetTpe.instance.encode(ctx, $ref)"
           case o =>
             throw new RuntimeException(s"BUG: Unexpected type: $o")
         }
       case c: TypeRef.Constructor =>
         c.id match {
           case TypeId.Builtins.opt =>
-            q"""$ref.map(v => ${mkEncoder(c.args.head, q"v")}).getOrElse(io.circe.Json.Null)"""
+            q"$ref.map(v => ${mkEncoder(c.args.head, q"v")}).getOrElse($circeJson.Null)"
 
           case TypeId.Builtins.map =>
             val keyEnc   = encodeKey(c.args.head, q"e._1")
             val valueEnc = mkEncoder(c.args.last, q"e._2")
-            q"""io.circe.Json.obj( $ref.map(e => ($keyEnc, $valueEnc)).toList: _* )"""
+            q"$circeJson.obj($ref.map(e => ($keyEnc, $valueEnc)).toList: _*)"
           case TypeId.Builtins.lst =>
-            q"""io.circe.Json.fromValues($ref.map(e => ${mkEncoder(c.args.head, q"e")}))"""
+            q"$circeJson.fromValues($ref.map(e => ${mkEncoder(c.args.head, q"e")}))"
           case TypeId.Builtins.set =>
-            q"""io.circe.Json.fromValues($ref.map(e => ${mkEncoder(c.args.head, q"e")}))"""
-          case o =>
-            throw new RuntimeException(s"BUG: Unexpected type: $o")
+            q"$circeJson.fromValues($ref.map(e => ${mkEncoder(c.args.head, q"e")}))"
+          case o => throw new RuntimeException(s"BUG: Unexpected type: $o")
         }
     }
   }
 
-  private def mkDecoder(tpe: TypeRef, ref: TextTree[ScValue]): TextTree[ScValue] = {
-    def mkReader(bs: TypeId.BuiltinScalar): TextTree[ScValue] = {
-      val fref = q"$ref"
-      bs match {
-        case TypeId.Builtins.bit => q"""$fref.flatMap(_.asBoolean).get"""
-        case TypeId.Builtins.i08 => q"""$fref.flatMap(_.asNumber).flatMap(_.toLong).map(_.toByte).get"""
-        case TypeId.Builtins.i16 => q"""$fref.flatMap(_.asNumber).flatMap(_.toLong).map(_.toShort).get"""
-        case TypeId.Builtins.i32 => q"""$fref.flatMap(_.asNumber).flatMap(_.toLong).map(_.toInt).get"""
-        case TypeId.Builtins.i64 => q"""$fref.flatMap(_.asNumber).flatMap(_.toLong).get"""
-        case TypeId.Builtins.u08 => q"""$fref.flatMap(_.asNumber).flatMap(_.toLong).map(_.toByte).get"""
-        case TypeId.Builtins.u16 => q"""$fref.flatMap(_.asNumber).flatMap(_.toLong).map(_.toShort).get"""
-        case TypeId.Builtins.u32 => q"""$fref.flatMap(_.asNumber).flatMap(_.toLong).map(_.toInt).get"""
-        case TypeId.Builtins.u64 => q"""$fref.flatMap(_.asNumber).flatMap(_.toBigInt).map(_.longValue).get"""
-
-        case TypeId.Builtins.f32   => q"""$fref.flatMap(_.asNumber).map(_.toFloat).get"""
-        case TypeId.Builtins.f64   => q"""$fref.flatMap(_.asNumber).map(_.toDouble).get"""
-        case TypeId.Builtins.f128  => q"""$fref.flatMap(_.asNumber).flatMap(_.toBigDecimal).get"""
-        case TypeId.Builtins.str   => q"""$fref.flatMap(_.asString).get"""
-        case TypeId.Builtins.bytes => q"""$fref.flatMap(_.asString).map($scByteString.parseHex).get"""
-        case TypeId.Builtins.uid   => q"""$fref.flatMap(_.asString).map(java.util.UUID.fromString).get"""
-        case TypeId.Builtins.tsu   => q"""$fref.flatMap(_.asString).flatMap($baboonTimeFormats.parseTsu).get"""
-        case TypeId.Builtins.tso   => q"""$fref.flatMap(_.asString).flatMap($baboonTimeFormats.parseTso).get"""
-        case other                 => throw new RuntimeException(s"BUG: Unexpected type: $other")
-      }
-    }
-
-    def decodeKey(tpe: TypeRef, ref: TextTree[ScValue]): TextTree[ScValue] = {
-      tpe.id match {
-        case TypeId.Builtins.bit   => q"""$ref.toBoolean"""
-        case TypeId.Builtins.i08   => q"""$ref.toByte"""
-        case TypeId.Builtins.i16   => q"""$ref.toShort"""
-        case TypeId.Builtins.i32   => q"""$ref.toInt"""
-        case TypeId.Builtins.i64   => q"""$ref.toLong"""
-        case TypeId.Builtins.u08   => q"""$ref.toByte"""
-        case TypeId.Builtins.u16   => q"""$ref.toShort"""
-        case TypeId.Builtins.u32   => q"""$ref.toInt"""
-        case TypeId.Builtins.u64   => q"""$ref.toLong"""
-        case TypeId.Builtins.f32   => q"""$ref.toFloat"""
-        case TypeId.Builtins.f64   => q"""$ref.toDouble"""
-        case TypeId.Builtins.f128  => q"""$ref.toBigDecimal"""
-        case TypeId.Builtins.str   => ref
-        case TypeId.Builtins.bytes => q"""ref.toHexString"""
-        case TypeId.Builtins.uid   => q"""java.util.UUID.fromString($ref.toString)"""
-        case TypeId.Builtins.tsu   => q"""$baboonTimeFormats.parseTsu($ref).get"""
-        case TypeId.Builtins.tso   => q"""$baboonTimeFormats.parseTso($ref).get"""
-
-        case uid: TypeId.User =>
-          domain.defs.meta.nodes(uid) match {
-            case u: DomainMember.User =>
-              u.defn match {
-                case _: Typedef.Enum | _: Typedef.Foreign =>
-                  val targetTpe =
-                    trans.toScTypeRefKeepForeigns(uid, domain, evo)
-                  q"""${targetTpe}_JsonCodec.instance.decode(ctx, io.circe.Json.fromString($ref)).right.get"""
+  private def decoder(fieldName: String, tpe: TypeRef, jsonObjectRef: TextTree[ScValue]): TextTree[ScValue] = {
+    def getKeyDecoder(typeRef: TypeRef): TextTree[ScValue] = {
+      typeRef match {
+        case TypeRef.Scalar(id) =>
+          id match {
+            case s: TypeId.BuiltinScalar =>
+              s match {
+                case TypeId.Builtins.bit => q"$baboonDecodeKeyBoolean"
+                case TypeId.Builtins.i08 => q"$circeDecodeKeyByte"
+                case TypeId.Builtins.i16 => q"$circeDecodeKeyShort"
+                case TypeId.Builtins.i32 => q"$circeDecodeKeyInt"
+                case TypeId.Builtins.i64 => q"$circeDecodeKeyLong"
+                case TypeId.Builtins.u08 => q"$circeDecodeKeyByte"
+                case TypeId.Builtins.u16 => q"$circeDecodeKeyShort"
+                case TypeId.Builtins.u32 => q"$circeDecodeKeyInt"
+                case TypeId.Builtins.u64 => q"$baboonDecodeLong"
+
+                case TypeId.Builtins.f32   => q"$baboonDecodeKeyFloat"
+                case TypeId.Builtins.f64   => q"$circeDecodeKeyDouble"
+                case TypeId.Builtins.f128  => q"$baboonDecodeKeyBigDecimal"
+                case TypeId.Builtins.str   => q"$circeDecodeKeyString"
+                case TypeId.Builtins.bytes => q"$baboonDecodeKeyByteString"
+                case TypeId.Builtins.uid   => q"$circeDecodeKeyUUID"
+                case TypeId.Builtins.tsu   => q"$baboonDecodeKeyTsu"
+                case TypeId.Builtins.tso   => q"$baboonDecodeKeyTso"
+                case other                 => throw new RuntimeException(s"BUG: Unexpected type: $other")
+              }
+            case uid: TypeId.User =>
+              domain.defs.meta.nodes(uid) match {
+                case u: DomainMember.User =>
+                  u.defn match {
+                    case _: Typedef.Enum | _: Typedef.Foreign =>
+                      val targetTpe = trans.toScTypeRefKeepForeigns(uid, domain, evo)
+                      q"$circeKeyDecoder.instance(s => ${targetTpe}_JsonCodec.instance.decode(ctx, $circeJson.fromString(s)).toOption)"
+                    case o => throw new RuntimeException(s"BUG: Unexpected key usertype: $o")
+                  }
                 case o =>
-                  throw new RuntimeException(
-                    s"BUG: Unexpected key usertype: $o"
-                  )
+                  throw new RuntimeException(s"BUG: Type/usertype mismatch: $o")
               }
-            case o =>
-              throw new RuntimeException(s"BUG: Type/usertype mismatch: $o")
           }
-        case o =>
-          throw new RuntimeException(s"BUG: Unexpected key type: $o")
+        case _ => throw new Exception(s"collection cannot be key: $tpe")
       }
     }
 
-    tpe match {
-      case TypeRef.Scalar(bs: TypeId.BuiltinScalar) =>
-        mkReader(bs)
-
-      case TypeRef.Scalar(u: TypeId.User) =>
-        val targetTpe = trans.toScTypeRefKeepForeigns(u, domain, evo)
-        q"""$ref.flatMap(v => ${targetTpe}_JsonCodec.instance.decode(ctx, v).toOption).get"""
-
-      case TypeRef.Constructor(id, args) =>
-        id match {
-          case TypeId.Builtins.opt =>
-            // Handle JSON null specially: if e is null, return None; otherwise decode the value
-            // Use flatMap with Option() to ensure type compatibility: Option[T] from both branches
-            val innerDecoder = mkDecoder(args.head, q"Option(e)")
-            q"""$ref.flatMap(e => if (e.isNull) None else Option($innerDecoder))"""
-
-          case TypeId.Builtins.map =>
-            val keyDec   = decodeKey(args.head, q"kv._1")
-            val valueDec = mkDecoder(args.last, q"Option(kv._2)")
-
-            q"""$ref.flatMap(_.asObject).map(_.toList.map(kv => ($keyDec, $valueDec)).toMap).get"""
-          case TypeId.Builtins.lst =>
-            q"""$ref.flatMap(_.asArray).map(_.toList).map(e => e.map(e1 => ${mkDecoder(args.head, q"Option(e1)")})).get"""
-
-          case TypeId.Builtins.set =>
-            q"""$ref.flatMap(_.asArray).map(_.toSet).map(e => e.map(e1 => ${mkDecoder(args.head, q"Option(e1)")})).get"""
-
-          case o =>
-            throw new RuntimeException(s"BUG: Unexpected type: $o")
-        }
+    def getDecoder(tpe: TypeRef): TextTree[ScValue] = {
+      tpe match {
+        case TypeRef.Scalar(id) =>
+          id match {
+            case s: TypeId.BuiltinScalar =>
+              s match {
+                case TypeId.Builtins.bit => q"$circeDecodeBoolean"
+                case TypeId.Builtins.i08 => q"$baboonDecodeByte"
+                case TypeId.Builtins.i16 => q"$baboonDecodeShort"
+                case TypeId.Builtins.i32 => q"$baboonDecodeInt"
+                case TypeId.Builtins.i64 => q"$baboonDecodeLong"
+                case TypeId.Builtins.u08 => q"$baboonDecodeByte"
+                case TypeId.Builtins.u16 => q"$baboonDecodeShort"
+                case TypeId.Builtins.u32 => q"$baboonDecodeInt"
+                case TypeId.Builtins.u64 => q"$baboonDecodeLong"
+
+                case TypeId.Builtins.f32   => q"$circeDecodeFloat"
+                case TypeId.Builtins.f64   => q"$circeDecodeDouble"
+                case TypeId.Builtins.f128  => q"$circeDecodeBigDecimal"
+                case TypeId.Builtins.str   => q"$circeDecodeString"
+                case TypeId.Builtins.bytes => q"$baboonDecodeByteString"
+                case TypeId.Builtins.uid   => q"$circeDecodeUuid"
+                case TypeId.Builtins.tsu   => q"$baboonDecodeTsu"
+                case TypeId.Builtins.tso   => q"$baboonDecodeTso"
+                case other                 => throw new RuntimeException(s"BUG: Unexpected type: $other")
+              }
+            case u: TypeId.User =>
+              val targetTpe = trans.toScTypeRefKeepForeigns(u, domain, evo)
+              q"${targetTpe}_JsonCodec.circeDecoder"
+          }
+        case TypeRef.Constructor(id, args) =>
+          id match {
+            case TypeId.Builtins.opt => q"$circeDecodeOption(${getDecoder(args.head)})"
+            case TypeId.Builtins.map =>
+              val keyDec   = getKeyDecoder(args.head)
+              val valueDec = getDecoder(args(1))
+              q"$circeDecodeMap($keyDec, $valueDec)"
+            case TypeId.Builtins.lst => q"$circeDecodeList(${getDecoder(args.head)})"
+            case TypeId.Builtins.set => q"$circeDecodeSet(${getDecoder(args.head)})"
+            case o                   => throw new RuntimeException(s"BUG: Unexpected type: $o")
+          }
+      }
     }
 
+    val field   = q"getField($jsonObjectRef, \"$fieldName\")"
+    val decoder = getDecoder(tpe)
+    q"$field.flatMap(v => $decoder(v.hcursor))"
   }
 
   private def renderMeta(defn: DomainMember.User, meta: List[MetaField]): List[TextTree[ScValue]] = {
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeInfo.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeInfo.scala
deleted file mode 100644
index 13e7a3d5..00000000
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeInfo.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-package io.septimalmind.baboon.translator.scl
-
-import io.septimalmind.baboon.typer.model.TypeId
-
-class ScTypeInfo {
-  def adtNsName(id: TypeId.User): String = {
-    id.name.name
-  }
-}
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeTranslator.scala
index dcf0ac58..510f90b7 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypeTranslator.scala
@@ -7,9 +7,7 @@ import izumi.fundamentals.collections.nonempty.NEList
 import izumi.fundamentals.platform.strings.TextTree
 import izumi.fundamentals.platform.strings.TextTree.Quote
 
-class ScTypeTranslator(
-  scTypeInfo: ScTypeInfo
-) {
+class ScTypeTranslator {
   def asScRef(tpe: TypeRef, domain: Domain, evo: BaboonEvolution): TextTree[ScValue] = {
     tpe match {
       case TypeRef.Scalar(id) =>
@@ -105,13 +103,9 @@ class ScTypeTranslator(
 
   private def renderOwner(owner: Owner): Seq[String] = {
     owner match {
-      case Owner.Toplevel =>
-        Seq.empty
-      case Owner.Ns(path) =>
-        path.map(_.name.toLowerCase)
-      case Owner.Adt(id) =>
-        val sub = renderOwner(id.owner) :+ scTypeInfo.adtNsName(id)
-        sub
+      case Owner.Toplevel => Seq.empty
+      case Owner.Ns(path) => path.map(_.name.toLowerCase)
+      case Owner.Adt(id)  => renderOwner(id.owner) :+ id.name.name
     }
   }
 }
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypes.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypes.scala
index cc19e237..be16eb9d 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypes.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScTypes.scala
@@ -23,6 +23,20 @@ object ScTypes {
   val baboonJsonCodecNoEncoderGenerated: ScType    = ScType(baboonRuntimePkg, "BaboonJsonCodec.NoEncoderGenerated")
   val baboonJsonCodecNoEncoderGeneratedAdt: ScType = ScType(baboonRuntimePkg, "BaboonJsonCodec.NoEncoderGeneratedAdt")
 
+  val baboonDecodeLong                  = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeLong")
+  val baboonDecodeByte: ScType          = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeByte")
+  val baboonDecodeShort: ScType         = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeShort")
+  val baboonDecodeInt: ScType           = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeInt")
+  val baboonDecodeTsu: ScType           = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeTsu")
+  val baboonDecodeTso: ScType           = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeTso")
+  val baboonDecodeByteString: ScType    = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeByteString")
+  val baboonDecodeKeyBoolean: ScType    = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeKeyBoolean")
+  val baboonDecodeKeyFloat: ScType      = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeKeyFloat")
+  val baboonDecodeKeyBigDecimal: ScType = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeKeyBigDecimal")
+  val baboonDecodeKeyTso: ScType        = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeKeyTso")
+  val baboonDecodeKeyTsu: ScType        = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeKeyTsu")
+  val baboonDecodeKeyByteString: ScType = ScType(baboonRuntimePkg, "BaboonJsonCodec.decodeKeyByteString")
+
   val baboonBinCodec: ScType                      = ScType(baboonRuntimePkg, "BaboonBinCodec")
   val baboonBinCodecBase: ScType                  = ScType(baboonRuntimePkg, "BaboonBinCodec.Base")
   val baboonBinCodecBaseGenerated: ScType         = ScType(baboonRuntimePkg, "BaboonBinCodec.BaseGenerated")
@@ -47,9 +61,11 @@ object ScTypes {
   val baboonAbstractConversion  = ScType(baboonRuntimePkg, "AbstractConversion")
   val baboonAbstractConversions = ScType(baboonRuntimePkg, "AbstractBaboonConversions")
 
+  // scala
+
   val scalaPkg: ScPackageId = parseScPkg("_root_.scala")
 
-  val deprecated: ScType = ScType(scalaPkg, "deprecated")
+  val deprecated: ScType = ScType(scalaPkg, "deprecated", predef = true)
 
   val scBoolean: ScType    = ScType(scalaPkg, "Boolean", predef = true)
   val scByte: ScType       = ScType(scalaPkg, "Byte", predef = true)
@@ -63,44 +79,85 @@ object ScTypes {
   val scArray: ScType      = ScType(scalaPkg, "Array", predef = true)
 
   // Scala collection types
-  val scOption: ScType = ScType(scalaPkg, "Option")
+  val scOption: ScType = ScType(scalaPkg, "Option", predef = true)
 
+  // immutable collections
   val scalaCollImmuPkg: ScPackageId = parseScPkg("scala.collection.immutable")
   val scList: ScType                = ScType(scalaCollImmuPkg, "List", predef = true)
   val scSet: ScType                 = ScType(scalaCollImmuPkg, "Set", predef = true)
   val scMap: ScType                 = ScType(scalaCollImmuPkg, "Map", predef = true)
 
+  // mutable collections
   val scalaCollMutPkg: ScPackageId = parseScPkg("scala.collection.mutable")
   val scMutMap: ScType             = ScType(scalaCollMutPkg, "Map", predef = true)
 
+  // util
   val scalaUtilPkg: ScPackageId = parseScPkg("scala.util")
   val scEither: ScType          = ScType(scalaUtilPkg, "Either", predef = true)
+  val scTry: ScType             = ScType(scalaUtilPkg, "Try")
+
+  // scalatest
+  val scalatestPkg: ScPackageId = parseScPkg("org.scalatest.flatspec")
+  val anyFlatSpec: ScType       = ScType(scalatestPkg, "AnyFlatSpec")
+
+  // java
 
+  // util
   val javaUtilPkg: ScPackageId = parseScPkg("java.util")
   val scUid: ScType            = ScType(javaUtilPkg, "UUID")
 
-  val javaLangPkg: ScPackageId = parseScPkg("java.lang")
-  val scString: ScType         = ScType(javaLangPkg, "String", predef = true)
-  val genericException: ScType = ScType(javaLangPkg, "RuntimeException")
-  val javaClass: ScType        = ScType(javaLangPkg, "Class", predef = true)
+  // lang
+  val javaLangPkg: ScPackageId             = parseScPkg("java.lang")
+  val scString: ScType                     = ScType(javaLangPkg, "String", predef = true)
+  val genericException: ScType             = ScType(javaLangPkg, "RuntimeException")
+  val javaClass: ScType                    = ScType(javaLangPkg, "Class", predef = true)
+  val javaThrowable: ScType                = ScType(javaLangPkg, "Throwable", predef = true)
+  val javaIllegalArgumentException: ScType = ScType(javaLangPkg, "IllegalArgumentException", predef = true)
 
+  // time
   val javaTimePkg: ScPackageId = parseScPkg("java.time")
   val scTime: ScType           = ScType(javaTimePkg, "OffsetDateTime")
 
-  val javaIoPkg: ScPackageId = parseScPkg("java.io")
-
+  // io
+  val javaIoPkg: ScPackageId        = parseScPkg("java.io")
   val byteArrayOutputStream: ScType = ScType(javaIoPkg, "ByteArrayOutputStream")
   val javaFile: ScType              = ScType(javaIoPkg, "File")
 
-  val scalatestPkg: ScPackageId = parseScPkg("org.scalatest.flatspec")
-  val anyFlatSpec: ScType       = ScType(scalatestPkg, "AnyFlatSpec")
-
+  // nio
   val javaNioFilePkg = parseScPkg("java.nio.file")
   val javaNioFiles   = ScType(javaNioFilePkg, "Files")
 
   val javaNioCharsetPkg       = parseScPkg("java.nio.charset")
   val javaNioStandardCharsets = ScType(javaNioCharsetPkg, "StandardCharsets")
 
+  // circe
+  val scalaCirce           = parseScPkg("io.circe")
+  val scalaCirceDecoder    = parseScPkg("io.circe.Decoder")
+  val scalaCirceKeyDecoder = parseScPkg("io.circe.KeyDecoder")
+
+  val circeJson       = ScType(scalaCirce, "Json")
+  val circeKeyDecoder = ScType(scalaCirce, "KeyDecoder")
+
+  val circeDecodeBoolean    = ScType(scalaCirceDecoder, "decodeBoolean")
+  val circeDecodeFloat      = ScType(scalaCirceDecoder, "decodeFloat")
+  val circeDecodeDouble     = ScType(scalaCirceDecoder, "decodeDouble")
+  val circeDecodeUuid       = ScType(scalaCirceDecoder, "decodeUUID")
+  val circeDecodeString     = ScType(scalaCirceDecoder, "decodeString")
+  val circeDecodeBigDecimal = ScType(scalaCirceDecoder, "decodeBigDecimal")
+
+  val circeDecodeOption = ScType(scalaCirceDecoder, "decodeOption")
+  val circeDecodeList   = ScType(scalaCirceDecoder, "decodeList")
+  val circeDecodeSet    = ScType(scalaCirceDecoder, "decodeSet")
+  val circeDecodeMap    = ScType(scalaCirceDecoder, "decodeMap")
+
+  val circeDecodeKeyByte   = ScType(scalaCirceKeyDecoder, "decodeKeyByte")
+  val circeDecodeKeyShort  = ScType(scalaCirceKeyDecoder, "decodeKeyShort")
+  val circeDecodeKeyInt    = ScType(scalaCirceKeyDecoder, "decodeKeyInt")
+  val circeDecodeKeyLong   = ScType(scalaCirceKeyDecoder, "decodeKeyLong")
+  val circeDecodeKeyDouble = ScType(scalaCirceKeyDecoder, "decodeKeyDouble")
+  val circeDecodeKeyUUID   = ScType(scalaCirceKeyDecoder, "decodeKeyUUID")
+  val circeDecodeKeyString = ScType(scalaCirceKeyDecoder, "decodeKeyString")
+
   def parsePkg(pkg: String): NEList[String] = NEList.unsafeFrom(pkg.split('.').toList)
   def parseScPkg(pkg: String): ScPackageId  = ScPackageId(parsePkg(pkg))
 }
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala
index 2f62fdb3..ffa701a5 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala
@@ -14,7 +14,6 @@ class ScUEBACodecGenerator(
   target: ScTarget,
   domain: Domain,
   evo: BaboonEvolution,
-  csTypeInfo: ScTypeInfo,
   scDomainTreeTools: ScDomainTreeTools,
 ) extends ScCodecTranslator {
 
@@ -86,7 +85,7 @@ class ScUEBACodecGenerator(
 
       case _: Typedef.Enum    => q"""0"""
       case _: Typedef.Adt     => q"""0"""
-      case _: Typedef.Foreign => q"""throw new IllegalArgumentException("${name.name} is a foreign type")"""
+      case _: Typedef.Foreign => q"""throw new $javaIllegalArgumentException("${name.name} is a foreign type")"""
 
       case d: Typedef.Contract =>
         throw new IllegalArgumentException(s"BUG: contract codec should not be rendered: $d")
@@ -110,7 +109,7 @@ class ScUEBACodecGenerator(
     } else Nil
 
     val decoderMethods = List(
-      q"""def decode(ctx: $baboonCodecContext, wire: $binaryInput): $name = {
+      q"""def decode(ctx: $baboonCodecContext, wire: $binaryInput): $scEither[$javaThrowable, $name] = {
          |  ${dec.shift(2).trim}
          |}""".stripMargin
     )
@@ -154,17 +153,17 @@ class ScUEBACodecGenerator(
      """.stripMargin
   }
 
-  private def genForeignBodies(name: ScValue.ScType): (TextTree[Nothing], TextTree[Nothing]) = {
+  private def genForeignBodies(name: ScValue.ScType): (TextTree[ScValue], TextTree[ScValue]) = {
     (
-      q"""throw new IllegalArgumentException("${name.name} is a foreign type")""",
-      q"""throw new IllegalArgumentException("${name.name} is a foreign type")""",
+      q"""throw new $javaIllegalArgumentException("${name.name} is a foreign type")""",
+      q"""throw new $javaIllegalArgumentException("${name.name} is a foreign type")""",
     )
   }
 
-  private def genAdtBodies(name: ScValue.ScType, a: Typedef.Adt): (TextTree[ScValue.ScType], TextTree[ScValue.ScType]) = {
-    val branches = a.dataMembers(domain).zipWithIndex.toList.map {
+  private def genAdtBodies(name: ScValue.ScType, adt: Typedef.Adt): (TextTree[ScValue.ScType], TextTree[ScValue.ScType]) = {
+    val branches = adt.dataMembers(domain).zipWithIndex.toList.map {
       case (m, idx) =>
-        val branchNs   = q"${csTypeInfo.adtNsName(a.id)}"
+        val branchNs   = q"${adt.id.name.name}"
         val branchName = m.name.name
         val fqBranch   = q"$branchNs.$branchName"
 
@@ -182,33 +181,33 @@ class ScUEBACodecGenerator(
         }
 
         val decBody = if (target.language.wrappedAdtBranchCodecs) {
-          q"""return $cName.instance.asInstanceOf[$cName.type].decodeBranch(ctx, wire)"""
+          q"""$cName.instance.asInstanceOf[$cName.type].decodeBranch(ctx, wire)"""
         } else {
-          q"""return $cName.instance.decode(ctx, wire)"""
+          q"""$cName.instance.decode(ctx, wire)"""
         }
 
         (
           q"""case $castedName: $fqBranch => 
              |  ${encBody.shift(2).trim}
              |""".stripMargin,
-          q"""if (asByte == ${idx.toString}) {
-             |  ${decBody.shift(2).trim}
-             |}""".stripMargin,
+          q"""case ${idx.toString} => $decBody
+             |""".stripMargin,
         )
     }
 
     (
       q"""value match {
          |  ${branches.map(_._1).joinN().shift(2).trim}
-         |
-         |  case _ => throw new $genericException(s"Cannot encode {value} to ${name.name}: no matching value")
          |}
          |""".stripMargin,
       q"""val asByte = wire.readByte();
          |
-         |${branches.map(_._2).joinN()}
+         |asByte match {
+         |  ${branches.map(_._2).joinN().shift(2).trim}
          |
-         |throw new $genericException(s"Cannot decode {wire} to ${name.name}: no matching value")""".stripMargin,
+         |  case _ => Left(new $genericException(s"Cannot decode {wire} to ${name.name}: no matching value"))
+         |}
+         |""".stripMargin,
     )
   }
 
@@ -216,27 +215,23 @@ class ScUEBACodecGenerator(
     val branches = e.members.zipWithIndex.toList.map {
       case (m, idx) =>
         (
-          q"""if (value == $name.${m.name})
-             |{
-             |   writer.writeByte(${idx.toString})
-             |   return
-             |}""".stripMargin,
-          q"""if (asByte == ${idx.toString})
-             |{
-             |   return $name.${m.name}
-             |}""".stripMargin,
+          q"case $name.${m.name} => writer.writeByte(${idx.toString})",
+          q"case ${idx.toString} => Right($name.${m.name})",
         )
     }
 
     (
-      q"""${branches.map(_._1).joinN()}
-         |
-         |throw new $genericException(s"Cannot encode {value} to ${name.name}: no matching value")""".stripMargin,
+      q"""value match {
+         |  ${branches.map(_._1).joinN().shift(2)}
+         |}
+         """.stripMargin,
       q"""val asByte = wire.readByte()
          |
-         |${branches.map(_._2).joinN()}
-         |
-         |throw new $genericException(s"Cannot decode {wire} to ${name.name}: no matching value")""".stripMargin,
+         |asByte match {
+         |  ${branches.map(_._2).joinN().shift(2)}
+         |  case _ => Left(new $genericException(s"Cannot decode {wire} to ${name.name}: no matching value"))
+         |}
+         |""".stripMargin,
     )
   }
 
@@ -244,18 +239,17 @@ class ScUEBACodecGenerator(
     name: ScValue.ScType,
     d: Typedef.Dto,
   ): Option[TextTree[ScValue]] = {
-
     d.id.owner match {
       case Owner.Adt(_) if target.language.wrappedAdtBranchCodecs =>
         val fields = fieldsOf(d)
-        Some(dtoDec(name, fields.map { case (a, b, _) => (a, b) }))
+        Some(dtoDec(name, fields.map(_._2)))
       case _ =>
         None
     }
   }
 
-  private def genDtoBodies(name: ScValue.ScType, d: Typedef.Dto) = {
-    val fields = fieldsOf(d)
+  private def genDtoBodies(name: ScValue.ScType, dto: Typedef.Dto): (TextTree[ScValue], TextTree[ScValue]) = {
+    val fields = fieldsOf(dto)
 
     val noIndex = Seq(
       q"writer.writeByte(header.toInt)",
@@ -265,8 +259,7 @@ class ScUEBACodecGenerator(
     val fenc =
       q"""var header: $scByte = 0b0000000;
          |
-         |if (ctx.useIndices)
-         |{
+         |if (ctx.useIndices) {
          |  header = (header | 0b0000001).toByte
          |  writer.writeByte(header.toInt)
          |  val writeMemoryStream = new $byteArrayOutputStream()
@@ -287,8 +280,7 @@ class ScUEBACodecGenerator(
          |}
          |""".stripMargin
 
-    val fdec =
-      dtoDec(name, fields.map { case (a, b, _) => (a, b) })
+    val fdec = dtoDec(name, fields.map(_._2))
 
     def adtBranchIndex(id: TypeId.User) = {
       domain.defs.meta
@@ -298,12 +290,12 @@ class ScUEBACodecGenerator(
         .asInstanceOf[Typedef.Adt]
         .dataMembers(domain)
         .zipWithIndex
-        .find(_._1 == d.id)
+        .find(_._1 == dto.id)
         .get
         ._2
     }
 
-    val enc = d.id.owner match {
+    val enc = dto.id.owner match {
       case Owner.Adt(id) if target.language.wrappedAdtBranchCodecs =>
         val idx = adtBranchIndex(id)
 
@@ -312,45 +304,43 @@ class ScUEBACodecGenerator(
       case _ => fenc
     }
 
-    val dec = d.id.owner match {
+    val dec = dto.id.owner match {
       case Owner.Adt(id) if target.language.wrappedAdtBranchCodecs =>
         val idx = adtBranchIndex(id)
-
         q"""val marker = wire.readByte()
            |assert(marker == ${idx.toString})
            |decodeBranch(ctx, wire)""".stripMargin
       case _ => fdec
     }
-
     (enc, dec)
   }
 
-  private def dtoDec(name: ScValue.ScType, fields: List[(TextTree[ScValue], TextTree[ScValue])]) = {
-    q"""val index = this.readIndex(ctx, wire)
-       |
-       |if (ctx.useIndices)
-       |{
-       |  assert(index.size == indexElementsCount(ctx))
-       |}
-       |
-       |$name(
-       |${fields.map(_._2).join(",\n").shift(2)}
-       |);
+  private def dtoDec(name: ScValue.ScType, fields: List[TextTree[ScValue]]): TextTree[ScValue] = {
+    q"""for {
+       |  index  <- this.readIndex(ctx, wire)
+       |  _      <- $scTry(if (ctx.useIndices) assert(index.size == indexElementsCount(ctx)) else ()).toEither
+       |  result <- $scTry {
+       |    $name(
+       |      ${fields.join(",\n").shift(6).trim}
+       |    )
+       |  }.toEither
+       |} yield result
        |""".stripMargin
   }
 
-  private def fieldsOf(d: Typedef.Dto) = {
-    d.fields.map {
-      f =>
-        val fieldRef = q"value.${f.name.name}"
-        val enc      = mkEncoder(f.tpe, fieldRef, q"writer")
-        val fakeEnc  = mkEncoder(f.tpe, fieldRef, q"fakeWriter")
-        val dec      = mkDecoder(f.tpe)
+  private def fieldsOf(dto: Typedef.Dto): List[(TextTree[ScValue], TextTree[ScValue], TextTree[ScValue])] = {
+    dto.fields.map {
+      field =>
+        val fieldRef   = q"value.${field.name.name}"
+        val enc        = mkEncoder(field.tpe, fieldRef, q"writer")
+        val fakeEnc    = mkEncoder(field.tpe, fieldRef, q"fakeWriter")
+        val decoder    = mkDecoder(field.tpe)
+        val decodeTree = q"${field.name.name} = $decoder"
 
-        val w = domain.refMeta(f.tpe).len match {
+        val w = domain.refMeta(field.tpe).len match {
           case BinReprLen.Fixed(bytes) =>
             q"""{
-               |  // ${f.toString}
+               |  // ${field.toString}
                |  val before = writeMemoryStream.size()
                |  ${fakeEnc.shift(2).trim}
                |  val after = writeMemoryStream.size()
@@ -374,7 +364,7 @@ class ScUEBACodecGenerator(
             }
 
             q"""{
-               |  // ${f.toString}
+               |  // ${field.toString}
                |  val before = writeMemoryStream.size()
                |  writer.writeInt(before)
                |  ${fakeEnc.shift(2).trim}
@@ -385,7 +375,7 @@ class ScUEBACodecGenerator(
                |}""".stripMargin
         }
 
-        (enc, dec, w)
+        (enc, decodeTree, w)
     }
   }
 
@@ -419,12 +409,12 @@ class ScUEBACodecGenerator(
             }
           case u: TypeId.User =>
             val targetTpe = codecName(trans.toScTypeRefKeepForeigns(u, domain, evo))
-            q"""$targetTpe.instance.decode(ctx, wire)"""
+            q"""$targetTpe.instance.decode(ctx, wire).toTry.get"""
         }
       case c: TypeRef.Constructor =>
         c.id match {
           case TypeId.Builtins.opt =>
-            q"""( if (wire.read() == 0) $scOption.empty else $scOption(${mkDecoder(c.args.head)}) )""".stripMargin
+            q"""(if (wire.read() == 0) $scOption.empty else $scOption(${mkDecoder(c.args.head)}))""".stripMargin
           case TypeId.Builtins.map =>
             val keyDecoder   = mkDecoder(c.args.head)
             val valueDecoder = mkDecoder(c.args.last)
@@ -473,12 +463,10 @@ class ScUEBACodecGenerator(
       case c: TypeRef.Constructor =>
         c.id match {
           case TypeId.Builtins.opt =>
-            q"""if ($ref.isEmpty)
-               |{
+            q"""if ($ref.isEmpty) {
                |  $wref.writeByte(0);
                |}
-               |else
-               |{
+               |else {
                |  $wref.writeByte(1);
                |  ${mkEncoder(c.args.head, q"$ref.get", wref).shift(2).trim}
                |}""".stripMargin
@@ -489,7 +477,6 @@ class ScUEBACodecGenerator(
                |  case (k, v) =>
                |  ${mkEncoder(c.args.head, q"k", wref).shift(2).trim}
                |  ${mkEncoder(c.args.last, q"v", wref).shift(2).trim}
-               |
                |}""".stripMargin
 
           case TypeId.Builtins.lst =>

From e0ab712d8ab4bd29cd6dae30bf4d6bd3016035e3 Mon Sep 17 00:00:00 2001
From: nikita-ty754 <nikitatishchenko1@gmail.com>
Date: Tue, 16 Dec 2025 10:52:47 +0200
Subject: [PATCH 3/6] ref

---
 .mdl/defs/tests.md                                 |  4 +++-
 .../scala/io/septimalmind/baboon/BaboonJS.scala    | 14 ++++++++++++--
 .../translator/scl/ScCodecTestsTranslator.scala    |  8 ++++----
 .../baboon/typer/ComponentParsers.scala            |  1 -
 .../src/test/scala/example/Test_Conversions.scala  |  7 ++++---
 .../scala/example/Test_CrossLanguageCompat.scala   |  7 +++++--
 6 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/.mdl/defs/tests.md b/.mdl/defs/tests.md
index 70171230..9c6a5a95 100644
--- a/.mdl/defs/tests.md
+++ b/.mdl/defs/tests.md
@@ -56,7 +56,9 @@ $BABOON_BIN \
   --test-output "$TEST_DIR/sc-stub/src/test/scala/generated-tests" \
   --fixture-output "$TEST_DIR/sc-stub/src/main/scala/generated-fixtures" \
   --sc-write-evolution-dict true \
-  --sc-wrapped-adt-branch-codecs false
+  --sc-wrapped-adt-branch-codecs false \ 
+  --generate-ueba-codecs-by-default=true \
+  --generate-json-codecs-by-default=true \
 
 ret success:bool=true
 ret test_dir:string="$TEST_DIR"
diff --git a/baboon-compiler/.js/src/main/scala/io/septimalmind/baboon/BaboonJS.scala b/baboon-compiler/.js/src/main/scala/io/septimalmind/baboon/BaboonJS.scala
index d1874dbd..95c35875 100644
--- a/baboon-compiler/.js/src/main/scala/io/septimalmind/baboon/BaboonJS.scala
+++ b/baboon-compiler/.js/src/main/scala/io/septimalmind/baboon/BaboonJS.scala
@@ -164,6 +164,11 @@ object BaboonJS {
   trait JSScOptions extends js.Object {
     val writeEvolutionDict: js.UndefOr[Boolean]
     val wrappedAdtBranchCodecs: js.UndefOr[Boolean]
+    val enableDeprecatedEncoders: js.UndefOr[Boolean]
+    val generateJsonCodecs: js.UndefOr[Boolean]
+    val generateUebaCodecs: js.UndefOr[Boolean]
+    val generateUebaCodecsByDefault: js.UndefOr[Boolean]
+    val generateJsonCodecsByDefault: js.UndefOr[Boolean]
   }
 
   @js.native
@@ -253,8 +258,13 @@ object BaboonJS {
               output  = createOutputOptions(target.generic),
               generic = createGenericOptions(target.generic),
               language = ScOptions(
-                writeEvolutionDict     = opts.writeEvolutionDict.getOrElse(false),
-                wrappedAdtBranchCodecs = opts.wrappedAdtBranchCodecs.getOrElse(false),
+                writeEvolutionDict          = opts.writeEvolutionDict.getOrElse(false),
+                wrappedAdtBranchCodecs      = opts.wrappedAdtBranchCodecs.getOrElse(false),
+                enableDeprecatedEncoders    = opts.enableDeprecatedEncoders.getOrElse(false),
+                generateJsonCodecs          = opts.generateJsonCodecs.getOrElse(true),
+                generateUebaCodecs          = opts.generateUebaCodecs.getOrElse(true),
+                generateJsonCodecsByDefault = opts.generateJsonCodecsByDefault.getOrElse(false),
+                generateUebaCodecsByDefault = opts.generateUebaCodecsByDefault.getOrElse(false),
               ),
             )
           case other => throw new IllegalArgumentException(s"Unknown target language: $other")
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala
index 28e2b487..8d0fc611 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScCodecTestsTranslator.scala
@@ -74,7 +74,7 @@ object ScCodecTestsTranslator {
              |
              |def jsonCompare(context: $baboonCodecContext, fixture: $srcRef, clue: $scString): io.circe.Json = {
              |  val fixtureJson    = $codecName.instance.encode(context, fixture)
-             |  val fixtureDecoded = $codecName.instance.decode(context, fixtureJson).toOption.get
+             |  val fixtureDecoded = $codecName.instance.decode(context, fixtureJson).toTry.get
              |  assert(fixture == fixtureDecoded, s"$$clue")
              |  fixtureJson
              |}
@@ -85,7 +85,7 @@ object ScCodecTestsTranslator {
              |  assume(f.exists())
              |  val b = $javaNioFiles.readAllBytes(f.toPath)
              |  import io.circe.parser.parse
-             |  val csJson = parse(new $scString(b, $javaNioStandardCharsets.UTF_8)).toOption.get
+             |  val csJson = parse(new $scString(b, $javaNioStandardCharsets.UTF_8)).toTry.get
              |  val dec = $codecName.instance.decode(context, csJson).toOption
              |  assert(dec.nonEmpty)
              |  jsonCompare(context, dec.get, clue)
@@ -120,7 +120,7 @@ object ScCodecTestsTranslator {
              |  val csUebaBytes = $javaNioFiles.readAllBytes(f.toPath)
              |  val bais = new java.io.ByteArrayInputStream(csUebaBytes)
              |  val dis = new $binaryInput(bais)
-             |  val dec = $codecName.instance.decode(context, dis).toOption.get
+             |  val dec = $codecName.instance.decode(context, dis).toTry.get
              |  val sclUebaBytes = uebaCompare(context, dec, clue)
              |  assert(csUebaBytes.length == sclUebaBytes.length, s"$$clue")
              |}
@@ -134,7 +134,7 @@ object ScCodecTestsTranslator {
              |  
              |  val bais = new java.io.ByteArrayInputStream(bytes)
              |  val dis = new $binaryInput(bais)
-             |  val dec = $codecName.instance.decode(context, dis).toOption.get
+             |  val dec = $codecName.instance.decode(context, dis).toTry.get
              |  assert(fixture == dec, s"$$clue")
              |  
              |  bytes
diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/typer/ComponentParsers.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/typer/ComponentParsers.scala
index 37c76a97..5020dd0c 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/typer/ComponentParsers.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/typer/ComponentParsers.scala
@@ -37,7 +37,6 @@ object ComponentParsers {
       version: RawVersion
     ): F[NEList[BaboonIssue], Version] = {
       for {
-        v <- F.pure(version.value)
         ret <- izumi.fundamentals.platform.versions.Version.parse(version.value) match {
           case c: izumi.fundamentals.platform.versions.Version.Canonical =>
             F.pure(c)
diff --git a/test/conv-test-sc/src/test/scala/example/Test_Conversions.scala b/test/conv-test-sc/src/test/scala/example/Test_Conversions.scala
index f593f013..cdc0e5ac 100644
--- a/test/conv-test-sc/src/test/scala/example/Test_Conversions.scala
+++ b/test/conv-test-sc/src/test/scala/example/Test_Conversions.scala
@@ -1,6 +1,7 @@
 package example
 
-import convtest.testpkg.{Adt0, BaboonConversions, RequiredConversions}
+import convtest.testpkg.BaboonConversions
+import convtest.testpkg.RequiredConversions
 import org.scalatest.flatspec.AnyFlatSpec
 
 class Test_Conversions extends AnyFlatSpec {
@@ -8,11 +9,11 @@ class Test_Conversions extends AnyFlatSpec {
     val a1   = new convtest.testpkg.v1_0_0.Adt0.B1("val1")
     val conv = new BaboonConversions(new RequiredConversions() {})
 
-    val a1u1 = conv.convertWithContext[Unit, convtest.testpkg.v1_0_0.Adt0.B1, convtest.testpkg.Adt0.B1]((), a1)
+    val a1u1 = conv.convertWithContext[Unit, convtest.testpkg.v1_0_0.Adt0.B1, convtest.testpkg.Adt0.B1](None, a1)
 
     assert(a1.f == a1u1.f)
 
-    val a1u2 = conv.convertWithContext[Unit, convtest.testpkg.v1_0_0.Adt0, convtest.testpkg.Adt0]((), a1)
+    val a1u2 = conv.convertWithContext[Unit, convtest.testpkg.v1_0_0.Adt0, convtest.testpkg.Adt0](None, a1)
 
     assert(a1u1 == a1u2)
 
diff --git a/test/conv-test-sc/src/test/scala/example/Test_CrossLanguageCompat.scala b/test/conv-test-sc/src/test/scala/example/Test_CrossLanguageCompat.scala
index 5529127c..dc0e3dd1 100644
--- a/test/conv-test-sc/src/test/scala/example/Test_CrossLanguageCompat.scala
+++ b/test/conv-test-sc/src/test/scala/example/Test_CrossLanguageCompat.scala
@@ -26,10 +26,13 @@ class Test_CrossLanguageCompat extends AnyFlatSpec {
 
   private def readUebaFile(source: String, format: String): AllBasicTypes = {
     val file = baseDir.resolve(s"$source-ueba/all-basic-types.ueba")
-    val fis  = new FileInputStream(file.toFile)
+    val fis = new FileInputStream(file.toFile)
     try {
       val reader = new LEDataInputStream(fis)
-      AllBasicTypes_UEBACodec.instance.decode(ctx, reader)
+      AllBasicTypes_UEBACodec.instance.decode(ctx, reader) match {
+        case Right(data) => data
+        case Left(error) => fail(s"Failed to decode $format UEBA: $error")
+      }
     } finally {
       fis.close()
     }

From f9202ce114f59763df31bde7e2104f609c57daf7 Mon Sep 17 00:00:00 2001
From: nikita-ty754 <nikitatishchenko1@gmail.com>
Date: Tue, 16 Dec 2025 13:23:44 +0200
Subject: [PATCH 4/6] ref

---
 .../baboon/translator/scl/ScJsonCodecGenerator.scala          | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala
index 00403c99..89494d1a 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScJsonCodecGenerator.scala
@@ -138,13 +138,11 @@ class ScJsonCodecGenerator(
           wrapAdtBranchEncoder(branchName, routedBranchEncoder)
         }
 
-        val branchValue = if (target.language.wrappedAdtBranchCodecs) q"wire" else q"json"
-
         (
           q"""case $branchNameRef: $fqBranch => $branchEncoder
              |""".stripMargin,
           q"""case "$branchName" =>
-             |  ${fqBranch}_JsonCodec.instance.decode(ctx, $branchValue)
+             |  ${fqBranch}_JsonCodec.instance.decode(ctx, json)
              |""".stripMargin,
         )
 

From 868742dcbbe0fed26c1df803386c95e1e48461c3 Mon Sep 17 00:00:00 2001
From: nikita-ty754 <nikitatishchenko1@gmail.com>
Date: Tue, 16 Dec 2025 13:38:39 +0200
Subject: [PATCH 5/6] ref

---
 .mdl/defs/tests.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/.mdl/defs/tests.md b/.mdl/defs/tests.md
index 9c6a5a95..0959d830 100644
--- a/.mdl/defs/tests.md
+++ b/.mdl/defs/tests.md
@@ -56,9 +56,9 @@ $BABOON_BIN \
   --test-output "$TEST_DIR/sc-stub/src/test/scala/generated-tests" \
   --fixture-output "$TEST_DIR/sc-stub/src/main/scala/generated-fixtures" \
   --sc-write-evolution-dict true \
-  --sc-wrapped-adt-branch-codecs false \ 
+  --sc-wrapped-adt-branch-codecs false \
   --generate-ueba-codecs-by-default=true \
-  --generate-json-codecs-by-default=true \
+  --generate-json-codecs-by-default=true
 
 ret success:bool=true
 ret test_dir:string="$TEST_DIR"
@@ -128,7 +128,9 @@ $BABOON_BIN \
   --test-output "$TEST_DIR/sc-stub/src/test/scala/generated-tests" \
   --fixture-output "$TEST_DIR/sc-stub/src/main/scala/generated-fixtures" \
   --sc-write-evolution-dict true \
-  --sc-wrapped-adt-branch-codecs true
+  --sc-wrapped-adt-branch-codecs true \
+  --generate-ueba-codecs-by-default=true \
+  --generate-json-codecs-by-default=true
 
 ret success:bool=true
 ret test_dir:string="$TEST_DIR"

From 4e49e7f36f3b0f85a62065a45271132966133d27 Mon Sep 17 00:00:00 2001
From: nikita-ty754 <nikitatishchenko1@gmail.com>
Date: Tue, 16 Dec 2025 13:55:27 +0200
Subject: [PATCH 6/6] ref

---
 .../baboon/translator/scl/ScUEBACodecGenerator.scala            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala
index ffa701a5..16186d79 100644
--- a/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala
+++ b/baboon-compiler/src/main/scala/io/septimalmind/baboon/translator/scl/ScUEBACodecGenerator.scala
@@ -117,7 +117,7 @@ class ScUEBACodecGenerator(
     val baseMethods = encoderMethods ++ decoderMethods
       ++ branchDecoder.map {
         body =>
-          q"""def decodeBranch(ctx: $baboonCodecContext, wire: $binaryInput): $name = {
+          q"""def decodeBranch(ctx: $baboonCodecContext, wire: $binaryInput): $scEither[$javaThrowable, $name] = {
              |  ${body.shift(2).trim}
              |}""".stripMargin
       }.toList ++ indexMethods