Update all codec README files with consistent import paths and basic usage

Co-authored-by: streamich <9773803+streamich@users.noreply.github.com>

Author: Copilot

src/bencode/README.md

@@ -1,18 +1,44 @@
-# 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
+
+## Basic Usage
+
+```ts
+import {BencodeEncoder, BencodeDecoder} from '@jsonjoy.com/json-pack/lib/bencode';
+
+const encoder = new BencodeEncoder();
+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
+```
+
+## 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`.
 - `Array` and `Set` are encoded as Bencode lists, decoded as `Array`.
 - `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:

src/bson/README.md

@@ -20,10 +20,10 @@ BSON (Binary JSON) is a binary representation of JSON-like documents. It extends
 - MongoDB-compatible implementation
 - Efficient binary representation
 
-## Usage
+## Basic Usage
 
 ```ts
-import {BsonEncoder, BsonDecoder} from 'json-pack/lib/bson';
+import {BsonEncoder, BsonDecoder} from '@jsonjoy.com/json-pack/lib/bson';
 
 const encoder = new BsonEncoder();
 const decoder = new BsonDecoder();
@@ -36,6 +36,8 @@ const data = {
 
 const encoded = encoder.encode(data);
 const decoded = decoder.decode(encoded);
+
+console.log(decoded); // Original data with BSON types preserved
 ```
 
 

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.

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();

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

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
 ```

src/json/README.md

@@ -10,17 +10,19 @@ Enhanced JSON implementation with high-performance encoding and decoding capabil
 - Binary-safe encoding/decoding
 - Optimized for repeated encoding operations
 
-## Usage
+## Basic Usage
 
 ```ts
-import {JsonEncoder, JsonDecoder} from 'json-pack/lib/json';
+import {JsonEncoder, JsonDecoder} from '@jsonjoy.com/json-pack/lib/json';
 
 const encoder = new JsonEncoder();
 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]}
 ```
 
 ## Performance

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();
 

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();