docs: trim README and link to technical deep dive

Author: rasros

README.md

@@ -33,6 +33,9 @@ KEncode provides three standalone entry points:
 3. **EncodedFormat**: A string format serializer that wraps the above to produce
    small deterministic string identifiers.
 
+For a walkthrough of the bit-packing layout and design choices, see the
+[technical deep dive](https://eignex.com/posts/kencode-packing-data-for-strict-limits/).
+
 ### Installation
 
 ```kotlin
@@ -71,19 +74,16 @@ val decoded = EncodedFormat.decodeFromString<Payload>(encoded)
 
 ## PackedFormat
 
-PackedFormat is a BinaryFormat designed to produce the smallest feasible
-payloads for Kotlin classes by moving structural metadata into a compact header.
+PackedFormat is a `BinaryFormat` for Kotlin classes that emits compact byte
+payloads.
 
-* Bit-Packing: Booleans and nullability markers are stored in a single
-  bit-header (about 1 bit per field).
-* VarInts: Int/Long fields can be optimized using `@PackedType(IntPacking.DEFAULT)`
-  (unsigned varint) or `@PackedType(IntPacking.SIGNED)` (ZigZag) annotations.
-  The names match `kotlinx-serialization-protobuf`'s `ProtoIntegerType`, and
-  `@ProtoType` annotations are recognized automatically as a fallback.
-* Full Graph Support: Handles nested objects, lists, maps, and polymorphism
-  recursively. While this is supported it will not produce as compact
-  representations as flat structures that can pack all metadata into the same
-  header.
+* Bit-Packing: Booleans and nullability markers share a single bit-header
+  (~1 bit per field).
+* VarInts: annotate `Int`/`Long` fields with `@PackedType(IntPacking.DEFAULT)`
+  (unsigned varint) or `@PackedType(IntPacking.SIGNED)` (ZigZag). `@ProtoType`
+  is recognized as a fallback.
+* Full Graph Support: nested objects, lists, maps, and polymorphism are
+  handled recursively.
 
 ```kotlin
 val compactFormat = PackedFormat {
@@ -104,10 +104,9 @@ composing three layers:
 
 1. Binary Layer: PackedFormat (default) or ProtoBuf (recommended for
    cross-language compatibility).
-2. Transform Layer: Optional `PayloadTransform` applied after serialization.
-   Use `CompactZeros` to strip leading zero bytes, `Checksum.asTransform()` for
-   integrity checks, or supply your own for encryption or error-correcting codes.
-   Chain multiple transforms with `PayloadTransform.then`.
+2. Transform Layer: Optional `PayloadTransform` applied after serialization
+   (e.g. `CompactZeros`, `Checksum.asTransform()`, or a custom transform for
+   encryption or ECC). Chain transforms with `PayloadTransform.then`.
 3. Text Layer: Base62 (default), Base36, Base64, or Base85.
 
 ```kotlin
@@ -132,10 +131,9 @@ val withBoth = EncodedFormat {
 KEncode includes standalone codecs for byte-to-text conversion. All
 implementations support custom alphabets.
 
-* Base62 / Base36: Uses fixed-block encoding for predictable lengths without
-  padding. Main use is to have 100% alpha-numeric output, with or without
-  upper-case.
-* Base85: High-density encoding (4 bytes to 5 characters).
+* Base62 / Base36: fixed-block encoding with predictable lengths and no
+  padding; alpha-numeric output, with or without upper-case.
+* Base85: high-density encoding (4 bytes → 5 characters).
 * Base64 / Base64Url: RFC 4648 compatible.
 
 Encoding `"any byte data"` (13 bytes):
@@ -175,7 +173,7 @@ val decoded = secureFormat.decodeFromString(SecretPayload.serializer(), token)
 ```
 
 See [EncryptionExample](https://github.com/Eignex/kencode/blob/main/src/jvmTest/kotlin/com/eignex/kencode/EncryptionExample.kt)
-for the full exapmle using BouncyCastle.
+for the full example using BouncyCastle.
 
 ### Error Correction