diff --git a/src/bencode/README.md b/src/bencode/README.md
index 011fb120..2098bfa5 100644
--- a/src/bencode/README.md
+++ b/src/bencode/README.md
@@ -1,10 +1,56 @@
-# Bencode codecs
+# Bencode Codec
 
 Implements [Bencode][bencode] encoder and decoder.
 
 [bencode]: https://en.wikipedia.org/wiki/Bencode
 
-Type coercion:
+## Features
+
+- High-performance Bencode encoding and decoding
+- Support for all standard Bencode types
+- Extensions for additional JavaScript types
+- BitTorrent-compatible implementation
+
+## Usage
+
+Note: BencodeEncoder requires a Writer instance from the `@jsonjoy.com/util` package. Make sure to install it as a peer dependency:
+
+```bash
+npm install @jsonjoy.com/util
+```
+
+### Basic Usage
+
+```ts
+import {BencodeEncoder, BencodeDecoder} from '@jsonjoy.com/json-pack/lib/bencode';
+import {Writer} from '@jsonjoy.com/util/lib/buffers/Writer';
+
+const writer = new Writer();
+const encoder = new BencodeEncoder(writer);
+const decoder = new BencodeDecoder();
+
+const data = {
+  name: 'example.torrent',
+  length: 1024,
+  files: ['file1.txt', 'file2.txt']
+};
+
+const encoded = encoder.encode(data);
+const decoded = decoder.decode(encoded);
+
+console.log(decoded); // Original data structure
+```
+
+### Alternative: Use simpler codecs
+
+For easier usage without external dependencies, consider using MessagePack or CBOR codecs instead:
+
+```ts
+import {MessagePackEncoder, MessagePackDecoder} from '@jsonjoy.com/json-pack/lib/msgpack';
+// ... simpler usage
+```
+
+## Type Coercion
 
 - Strings and `Uint8Array` are encoded as Bencode byte strings, decoded as `Uint8Array`.
 - `Object` and `Map` are encoded as Bencode dictionaries, decoded as `Object`.
@@ -12,7 +58,6 @@ Type coercion:
 - `number` and `bigint` are encoded as Bencode integers, decoded as `number`.
 - Float `number` are rounded and encoded as Bencode integers, decoded as `number`.
 
-
 ## Extensions
 
 This codec extends the Bencode specification to support the following types:
diff --git a/src/bson/README.md b/src/bson/README.md
index 176c95f5..1eb2ccf2 100644
--- a/src/bson/README.md
+++ b/src/bson/README.md
@@ -22,10 +22,20 @@ BSON (Binary JSON) is a binary representation of JSON-like documents. It extends
 
 ## Usage
 
+Note: BsonEncoder requires a Writer instance from the `@jsonjoy.com/util` package. Make sure to install it as a peer dependency:
+
+```bash
+npm install @jsonjoy.com/util
+```
+
+### Basic Usage
+
 ```ts
-import {BsonEncoder, BsonDecoder} from 'json-pack/lib/bson';
+import {BsonEncoder, BsonDecoder} from '@jsonjoy.com/json-pack/lib/bson';
+import {Writer} from '@jsonjoy.com/util/lib/buffers/Writer';
 
-const encoder = new BsonEncoder();
+const writer = new Writer();
+const encoder = new BsonEncoder(writer);
 const decoder = new BsonDecoder();
 
 const data = {
@@ -36,6 +46,17 @@ const data = {
 
 const encoded = encoder.encode(data);
 const decoded = decoder.decode(encoded);
+
+console.log(decoded); // Original data with BSON types preserved
+```
+
+### Alternative: Use simpler codecs
+
+For easier usage without external dependencies, consider using MessagePack or CBOR codecs instead:
+
+```ts
+import {MessagePackEncoder, MessagePackDecoder} from '@jsonjoy.com/json-pack/lib/msgpack';
+// ... simpler usage
 ```
 
 
diff --git a/src/cbor/README.md b/src/cbor/README.md
index eccba621..da79a490 100644
--- a/src/cbor/README.md
+++ b/src/cbor/README.md
@@ -5,36 +5,15 @@ and has no external dependencies.
 
 [cbor]: https://cbor.io/
 
-## Getting started
-
-To get started you need to import `CborEncoder` and `CborDecoder` classes like
-this:
-
-```ts
-import {CborEncoder} from 'json-joy/es2020/json-pack/cbor/CborEncoder';
-import {CborDecoder} from 'json-joy/es2020/json-pack/cbor/CborDecoder';
-```
-
-The `CborDecoder` implements full decoding feature set including advanced
-features like value skipping and decoding one level at-a-time. Those features
-are not necessary for most use cases, to save on bundle size you can import
-the "base" decoder instead:
+## Basic Usage
 
 ```ts
-import {CborDecoderBase} from 'json-joy/es2020/json-pack/cbor/CborDecoderBase';
-```
-
-The base decoder implements all CBOR decoding features except for the advanced
-shallow decoding features, like skipping, one level at-a-time decoding.
-
-## Usage
+import {CborEncoder, CborDecoder} from '@jsonjoy.com/json-pack/lib/cbor';
 
-Encode a JavaScript POJO to CBOR:
-
-```ts
 const encoder = new CborEncoder();
+const decoder = new CborDecoder();
 
-const pojo = {
+const data = {
   id: 123,
   foo: 'bar',
   tags: ['a', 'b', 'c'],
@@ -47,39 +26,34 @@ const pojo = {
   },
 };
 
-const encoded = encoder.encode(pojo);
-console.log(encoded);
-// Uint8Array(53) [
-//   164,  98, 105, 100,  24, 123,  99, 102, 111, 111,
-//    99,  98,  97, 114, 100, 116,  97, 103, 115, 131,
-//    97,  97,  97,  98,  97,  99, 120,   6, 110, 101,
-//   115, 116, 101, 100, 163,  97,  97,   1,  97,  98,
-//     2, 120,   6, 108, 101, 118, 101, 108,  50, 161,
-//    97,  99,   3
-// ]
+const encoded = encoder.encode(data);
+const decoded = decoder.decode(encoded);
+
+console.log(decoded); // Original data structure
 ```
 
-Decode CBOR back to JavaScript POJO:
+## Advanced Usage
+
+To get started you need to import `CborEncoder` and `CborDecoder` classes like
+this:
 
 ```ts
-const decoderBase = new CborDecoderBase();
-const decoded = decoderBase.read(encoded);
+import {CborEncoder} from '@jsonjoy.com/json-pack/lib/cbor/CborEncoder';
+import {CborDecoder} from '@jsonjoy.com/json-pack/lib/cbor/CborDecoder';
+```
+
+The `CborDecoder` implements full decoding feature set including advanced
+features like value skipping and decoding one level at-a-time. Those features
+are not necessary for most use cases, to save on bundle size you can import
+the "base" decoder instead:
 
-console.log(decoded);
-// {
-//   id: 123,
-//   foo: 'bar',
-//   tags: ['a', 'b', 'c'],
-//   nested: {
-//     a: 1,
-//     b: 2,
-//     level2: {
-//       c: 3,
-//     }
-//   },
-// }
+```ts
+import {CborDecoderBase} from '@jsonjoy.com/json-pack/lib/cbor/CborDecoderBase';
 ```
 
+The base decoder implements all CBOR decoding features except for the advanced
+shallow decoding features, like skipping, one level at-a-time decoding.
+
 ## Implementation details
 
 - Map keys are treated as strings.
diff --git a/src/ejson/README.md b/src/ejson/README.md
index 387ad613..208d1bfa 100644
--- a/src/ejson/README.md
+++ b/src/ejson/README.md
@@ -17,11 +17,32 @@ This directory contains the implementation of MongoDB Extended JSON v2 codec, pr
 - Throws descriptive errors for malformed input
 - Supports both canonical and relaxed format parsing
 
-## API
+## Basic Usage
+
+```ts
+import {EjsonEncoder, EjsonDecoder} from '@jsonjoy.com/json-pack/lib/ejson';
+
+const encoder = new EjsonEncoder();
+const decoder = new EjsonDecoder();
+
+const data = {
+  _id: new BsonObjectId(0x507f1f77, 0xbcf86cd799, 0x439011),
+  count: new BsonInt64(9223372036854775807),
+  created: new Date('2023-01-15T10:30:00.000Z')
+};
+
+const encoded = encoder.encode(data);
+const decoded = decoder.decode(encoded);
+
+console.log(decoded); // Original data with BSON types preserved
+```
+
+## Advanced Usage
 
 ### Binary-First API (Recommended for Performance)
+
 ```typescript
-import {EjsonEncoder, EjsonDecoder} from '@jsonjoy.com/json-pack/ejson2';
+import {EjsonEncoder, EjsonDecoder} from '@jsonjoy.com/json-pack/lib/ejson';
 import {Writer} from '@jsonjoy.com/util/lib/buffers/Writer';
 
 const writer = new Writer();
@@ -36,8 +57,9 @@ const result = decoder.decode(bytes);
 ```
 
 ### String API (For Compatibility)
+
 ```typescript
-import {createEjsonEncoder, createEjsonDecoder} from '@jsonjoy.com/json-pack/ejson2';
+import {createEjsonEncoder, createEjsonDecoder} from '@jsonjoy.com/json-pack/lib/ejson';
 
 const encoder = createEjsonEncoder({ canonical: true });
 const decoder = createEjsonDecoder();
diff --git a/src/ion/README.md b/src/ion/README.md
index 79e55f10..ecc242a1 100644
--- a/src/ion/README.md
+++ b/src/ion/README.md
@@ -2,7 +2,7 @@
 
 This library provides high-performance Amazon Ion binary format encoding and decoding capabilities.
 
-## Usage
+## Basic Usage
 
 ```typescript
 import {IonEncoderFast, IonDecoder} from '@jsonjoy.com/json-pack/lib/ion';
@@ -13,6 +13,8 @@ const decoder = new IonDecoder();
 const data = {users: [{name: 'Alice', age: 30}], count: 1};
 const encoded = encoder.encode(data);
 const decoded = decoder.decode(encoded);
+
+console.log(decoded); // Original data structure
 ```
 
 ## Important Usage Notes
diff --git a/src/json-binary/README.md b/src/json-binary/README.md
index 645c2997..bc985f7c 100644
--- a/src/json-binary/README.md
+++ b/src/json-binary/README.md
@@ -3,8 +3,10 @@
 A JSON serializer and parser which supports `Uint8Array` binary data.
 Encodes binary data as Base64 encoded data URI strings.
 
+## Basic Usage
+
 ```ts
-import * as JSONB from 'json-pack/lib/json-binary';
+import * as JSONB from '@jsonjoy.com/json-pack/lib/json-binary';
 
 const data = {
   foo: new Uint8Array([1, 2, 3]),
@@ -15,4 +17,6 @@ const json = JSONB.stringify(data);
 
 const data2 = JSONB.parse(json);
 // { foo: Uint8Array { 1, 2, 3 } }
+
+console.log(data2.foo instanceof Uint8Array); // true
 ```
diff --git a/src/json/README.md b/src/json/README.md
index 817914ca..aa664df3 100644
--- a/src/json/README.md
+++ b/src/json/README.md
@@ -12,15 +12,39 @@ Enhanced JSON implementation with high-performance encoding and decoding capabil
 
 ## Usage
 
+Note: JsonEncoder requires a Writer instance from the `@jsonjoy.com/util` package. Make sure to install it as a peer dependency:
+
+```bash
+npm install @jsonjoy.com/util
+```
+
+### Basic Usage
+
 ```ts
-import {JsonEncoder, JsonDecoder} from 'json-pack/lib/json';
+import {JsonEncoder, JsonDecoder} from '@jsonjoy.com/json-pack/lib/json';
+import {Writer} from '@jsonjoy.com/util/lib/buffers/Writer';
 
-const encoder = new JsonEncoder();
+const writer = new Writer();
+const encoder = new JsonEncoder(writer);
 const decoder = new JsonDecoder();
 
 const data = {hello: 'world', numbers: [1, 2, 3]};
 const encoded = encoder.encode(data);
 const decoded = decoder.decode(encoded);
+
+console.log(decoded); // {hello: 'world', numbers: [1, 2, 3]}
+```
+
+### Alternative: Use simpler codecs
+
+For easier usage without external dependencies, consider using MessagePack or CBOR codecs instead:
+
+```ts
+import {MessagePackEncoder, MessagePackDecoder} from '@jsonjoy.com/json-pack/lib/msgpack';
+
+const encoder = new MessagePackEncoder();
+const decoder = new MessagePackDecoder(); 
+// ... simpler usage
 ```
 
 ## Performance
diff --git a/src/msgpack/README.md b/src/msgpack/README.md
index 9271dfec..f839f374 100644
--- a/src/msgpack/README.md
+++ b/src/msgpack/README.md
@@ -44,14 +44,31 @@ messagepack x 2,740 ops/sec ±10.15% (49 runs sampled), 364983 ns/op
 ```
 
 
-## Usage
+## Basic Usage
+
+Use `MessagePackEncoder` and `MessagePackDecoder` to encode plain JSON values:
+
+```ts
+import {MessagePackEncoder, MessagePackDecoder} from '@jsonjoy.com/json-pack/lib/msgpack';
+
+const encoder = new MessagePackEncoder();
+const decoder = new MessagePackDecoder();
+
+const data = {foo: 'bar'};
+const buffer = encoder.encode(data);
+const obj = decoder.decode(buffer);
+
+console.log(obj); // { foo: 'bar' }
+```
+
+## Advanced Usage
 
 ### Basic usage
 
 Use `Encoder` to encode plain JSON values.
 
 ```ts
-import {Encoder, Decoder} from '{lib,es6,esm}/json-pack';
+import {Encoder, Decoder} from '@jsonjoy.com/json-pack/lib/msgpack';
 
 const encoder = new Encoder();
 const decoder = new Decoder();
@@ -65,7 +82,7 @@ Use `EncoderFull` to encode data that is more complex than plain JSON. For
 example, encode binary data using `ArrayBuffer`:
 
 ```ts
-import {EncoderFull, Decoder} from '{lib,es6,esm}/json-pack';
+import {EncoderFull, Decoder} from '@jsonjoy.com/json-pack/lib/msgpack';
 
 const encoder = new EncoderFull();
 const decoder = new Decoder();
@@ -81,13 +98,13 @@ You might have already encoded MessagePack value, to insert it into a bigger
 MessagePack object as-is use `JsonPackValue` wrapper.
 
 ```ts
-import {EncoderFull, Decoder, JsonPackValue} from '{lib,es6,esm}/json-pack';
+import {EncoderFull, Decoder, JsonPackValue} from '@jsonjoy.com/json-pack/lib/msgpack';
 
 const encoder = new EncoderFull();
 const decoder = new Decoder();
 const buffer = encoder.encode({foo: 'bar'});
 const value = new JsonPackValue(buffer);
-const buffer2 = encode({baz: value});
+const buffer2 = encoder.encode({baz: value});
 
 const obj = decoder.decode(buffer2);
 console.log(obj); // { baz: { foo: 'bar' } }
@@ -98,14 +115,14 @@ console.log(obj); // { baz: { foo: 'bar' } }
 Use `JsonPackExtension` wrapper to encode extensions.
 
 ```ts
-import {EncoderFull, Decoder, JsonPackExtension} from '{lib,es6,esm}/json-pack';
+import {EncoderFull, Decoder, JsonPackExtension} from '@jsonjoy.com/json-pack/lib/msgpack';
 
 const ext = new JsonPackExtension(1, new Uint8Array(8));
 const encoder = new EncoderFull();
 const decoder = new Decoder();
 const buffer = encoder.encode({foo: ext});
 
-const obj = decoder.decode(buffe2);
+const obj = decoder.decode(buffer);
 console.log(obj); // { foo: JsonPackExtension } 
 ```
 
@@ -132,7 +149,7 @@ result in different MessagePack blobs. Use `EncoderStable` to get stable
 MessagePack blobs.
 
 ```ts
-import {EncoderStable} from '{lib,es6,esm}/json-pack';
+import {EncoderStable} from '@jsonjoy.com/json-pack/lib/msgpack';
 
 const encoder = new EncoderStable();
 
diff --git a/src/msgpack/index.ts b/src/msgpack/index.ts
index 8268c5c3..c25e929d 100644
--- a/src/msgpack/index.ts
+++ b/src/msgpack/index.ts
@@ -32,7 +32,12 @@ export * from './types';
 export {MsgPackEncoderFast} from './MsgPackEncoderFast';
 export {MsgPackEncoder} from './MsgPackEncoder';
 export {MsgPackEncoderStable} from './MsgPackEncoderStable';
+export {MsgPackDecoder} from './MsgPackDecoder';
 export {MsgPackDecoderFast} from './MsgPackDecoderFast';
 export {MsgPackToJsonConverter} from './MsgPackToJsonConverter';
 export {JsonPackValue} from '../JsonPackValue';
 export {JsonPackExtension} from '../JsonPackExtension';
+
+// User-friendly aliases
+export {MsgPackEncoder as MessagePackEncoder} from './MsgPackEncoder';
+export {MsgPackDecoder as MessagePackDecoder} from './MsgPackDecoder';
diff --git a/src/resp/README.md b/src/resp/README.md
index 2f8bb3a7..72c3e187 100644
--- a/src/resp/README.md
+++ b/src/resp/README.md
@@ -35,10 +35,10 @@ RESP is the protocol used by Redis to communicate between clients and servers. T
 - Bulk strings  
 - Arrays
 
-## Usage
+## Basic Usage
 
 ```ts
-import {RespEncoder, RespDecoder} from 'json-pack/lib/resp';
+import {RespEncoder, RespDecoder} from '@jsonjoy.com/json-pack/lib/resp';
 
 const encoder = new RespEncoder();
 const decoder = new RespDecoder();
diff --git a/src/ubjson/README.md b/src/ubjson/README.md
index 4a1e7a9f..fca7e101 100644
--- a/src/ubjson/README.md
+++ b/src/ubjson/README.md
@@ -1,3 +1,53 @@
+# UBJSON Codec
+
+Universal Binary JSON (UBJSON) encoder and decoder with high-performance implementation.
+
+## Features
+
+- High-performance UBJSON encoding and decoding
+- Support for all UBJSON data types
+- About an order of magnitude faster than other implementations
+- Efficient binary representation
+
+## Usage
+
+Note: UbjsonEncoder requires a Writer instance from the `@jsonjoy.com/util` package. Make sure to install it as a peer dependency:
+
+```bash
+npm install @jsonjoy.com/util
+```
+
+### Basic Usage
+
+```ts
+import {UbjsonEncoder, UbjsonDecoder} from '@jsonjoy.com/json-pack/lib/ubjson';
+import {Writer} from '@jsonjoy.com/util/lib/buffers/Writer';
+
+const writer = new Writer();
+const encoder = new UbjsonEncoder(writer);
+const decoder = new UbjsonDecoder();
+
+const data = {
+  name: 'example',
+  numbers: [1, 2, 3],
+  nested: {value: 42}
+};
+
+const encoded = encoder.encode(data);
+const decoded = decoder.decode(encoded);
+
+console.log(decoded); // Original data structure
+```
+
+### Alternative: Use simpler codecs
+
+For easier usage without external dependencies, consider using MessagePack or CBOR codecs instead:
+
+```ts
+import {MessagePackEncoder, MessagePackDecoder} from '@jsonjoy.com/json-pack/lib/msgpack';
+// ... simpler usage
+```
+
 ## Limitations of the UBJSON format
 
 - Does not have a native "binary" type representation. Instead, octets are