@zio.dev/zio-blocks 0.0.30 → 0.0.32

package/guides/query-dsl-extending.md

@@ -52,7 +52,7 @@ Since `SchemaExpr` is a sealed trait, you cannot add new cases to it. Instead, w
 This guide builds on [Part 1: Expressions](./query-dsl-reified-optics.md) and [Part 2: SQL Generation](./query-dsl-sql.md). You should be comfortable building `SchemaExpr` values and translating them to SQL.
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.32"
 ```
 
 ```scala

package/guides/query-dsl-fluent-builder.md

@@ -57,7 +57,7 @@ In this guide, we solve both problems: bridge extensions eliminate `.toExpr`, an
 This guide builds on [Part 1: Expressions](./query-dsl-reified-optics.md), [Part 2: SQL Generation](./query-dsl-sql.md), and [Part 3: Extending the Expression Language](./query-dsl-extending.md).
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.32"
 ```
 
 ## Domain Setup

package/guides/query-dsl-reified-optics.md

@@ -43,7 +43,7 @@ In this guide, we'll solve this by using ZIO Blocks' `SchemaExpr` and reified op
 Add the ZIO Blocks Schema dependency:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.32"
 ```
 
 ```scala

package/guides/query-dsl-sql.md

@@ -43,7 +43,7 @@ Since `SchemaExpr` is a sealed trait, we can write a single interpreter that tra
 This guide builds on [Part 1: Expressions](./query-dsl-reified-optics.md). You should be comfortable building `SchemaExpr` values with optic operators (`===`, `>`, `&&`, etc.).
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.32"
 ```
 
 ```scala

package/guides/zio-schema-migration.md

@@ -38,13 +38,13 @@ libraryDependencies += "dev.zio" %% "zio-schema-avro"       % "1.x.x"
 **After (ZIO Blocks Schema):**
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema"            % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema"            % "0.0.32"
 // Optional codec modules:
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro"       % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift"     % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson"       % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon"       % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro"       % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift"     % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson"       % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon"       % "0.0.32"
 ```
 
 Key points:
@@ -536,7 +536,7 @@ val protoCodec: BinaryCodec[Person] = ProtobufCodec.protobufCodec(Person.schema)
 // ZIO Blocks Schema — all codecs via schema.derive(Format); return type inferred
 import zio.blocks.schema._
 import zio.blocks.schema.json.JsonFormat
-val jsonCodec = Person.schema.derive(JsonFormat)   // inferred: JsonBinaryCodec[Person]
+val jsonCodec = Person.schema.derive(JsonFormat)   // inferred: JsonCodec[Person]
 
 import zio.blocks.schema.avro.AvroFormat
 val avroCodec = Person.schema.derive(AvroFormat)
@@ -593,7 +593,7 @@ val codec = JsonCodec.jsonCodec(Person.schema)  // returns zio.json.JsonCodec
 
 // ZIO Blocks Schema — built into zio-blocks-schema; no extra dependency
 import zio.blocks.schema.json.JsonFormat
-val codec = Person.schema.derive(JsonFormat)  // returns JsonBinaryCodec[Person]
+val codec = Person.schema.derive(JsonFormat)  // returns JsonCodec[Person]
 ```
 
 ### Streaming Codecs

package/index.md

@@ -82,14 +82,14 @@ val thriftCodec  = Schema[Person].derive(ThriftFormat)      // Thrift
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.32"
 
 // Optional format modules:
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro" % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon" % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift" % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro" % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon" % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift" % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson" % "0.0.32"
 ```
 
 ### Example: Optics
@@ -144,7 +144,7 @@ Chunk is designed for:
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-chunk" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-chunk" % "0.0.32"
 ```
 
 ### Example
@@ -233,7 +233,7 @@ Scope.global.scoped { scope =>
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.32"
 ```
 
 ### Example: Basic Resource Management
@@ -342,7 +342,7 @@ Generating documentation, README files, or any Markdown content programmatically
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-docs" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-docs" % "0.0.32"
 ```
 
 ### Example
@@ -426,7 +426,7 @@ Compile-time type identity with rich metadata. TypeId captures comprehensive inf
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-typeid" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-typeid" % "0.0.32"
 ```
 
 ### Example
@@ -469,7 +469,7 @@ A type-indexed heterogeneous collection that stores values by their types with c
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-context" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-context" % "0.0.32"
 ```
 
 ### Example
@@ -521,7 +521,7 @@ Standard `java.util.concurrent` queues use node allocation (`ConcurrentLinkedQue
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-ringbuffer" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-ringbuffer" % "0.0.32"
 ```
 
 ### Example

package/package.json

@@ -2,7 +2,7 @@
   "name": "@zio.dev/zio-blocks",
   "description": "ZIO Blocks Documentation",
   "license": "Apache-2.0",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "repository": {
     "url": "https://github.com/zio/zio-blocks"
   }

package/reference/codec.md

@@ -19,7 +19,7 @@ abstract class Codec[DecodeInput, EncodeOutput, Value] {
 - **`encode`** writes the encoded form of `value` into `output`. The output parameter is typically a mutable buffer (`ByteBuffer`, `CharBuffer`) that the caller provides.
 - **`decode`** reads from `input` and returns either a `SchemaError` describing the failure or the decoded value.
 
-End users rarely interact with `Codec` directly. Instead, they work with format-specific subclasses like `JsonBinaryCodec[A]` or `ToonBinaryCodec[A]`, which add convenience methods for common input/output types.
+End users rarely interact with `Codec` directly. Instead, they work with format-specific subclasses like `JsonCodec[A]` or `ToonCodec[A]`, which add convenience methods for common input/output types.
 
 Given a `Schema[A]`, you can derive a codec for any supported format by calling `Schema[A].derive(format)`, which uses the `Deriver` associated with that format to generate the appropriate codec instance. For example, to derive a JSON codec:
 
@@ -32,8 +32,8 @@ case class Person(name: String, age: Int)
 object Person {
   // Derive a schema for Person (required for codec derivation)
   implicit val schema: Schema[Person] = Schema.derived
-   // Derive a JSON codec from the schema
-   implicit val codec: JsonBinaryCodec[Person] = schema.derive(JsonFormat)
+   // Derive a JSON codec from the schema 
+  val codec: JsonCodec[Person] = schema.derive(JsonFormat)
 }
 
 // Encode
@@ -48,23 +48,26 @@ val result: Either[SchemaError, Person] = Person.codec.decode(bytes)
 To include the base schema module with JSON support, add the following dependency to your `build.sbt`:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.32"
 ```
 
 Additional format modules are separate artifacts:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro"        % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon"        % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift"      % "0.0.30"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson"        % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro"        % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson"        % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-csv"         % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift"      % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon"        % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-xml"         % "0.0.32"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-yaml"        % "0.0.32"
 ```
 
 For cross-platform projects (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.32"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.
@@ -76,12 +79,15 @@ The codec system in ZIO Blocks is organized as a layered hierarchy:
 ```
 Codec[DecodeInput, EncodeOutput, Value]        
 ├── BinaryCodec[A] =  Codec[ByteBuffer, ByteBuffer, A]   (ByteBuffer ↔ A)
-│   ├── JsonBinaryCodec[A]                    
-│   ├── AvroBinaryCodec[A]                   
-│   ├── ToonBinaryCodec[A]                  
-│   ├── ThriftBinaryCodec[A]               
-│   └── MessagePackBinaryCodec[A]         
+│   ├── AvroCodec[A]                   
+│   ├── JsonCodec[A]                    
+│   ├── MessagePackCodec[A]         
+│   ├── ThriftCodec[A]               
+│   ├── ToonCodec[A]                  
+│   ├── XmlCodec[A]         
+│   └── YamlCodec[A]         
 └── TextCodec[A] = Codec[CharBuffer, CharBuffer, A]      (CharBuffer ↔ A)
+    └── CsvCodec[A]                    
 ```
 
 1. **`BinaryCodec[A]`** fixes both the input and output to `ByteBuffer` and is the base class for all codecs that operate on binary data:
@@ -116,7 +122,7 @@ object Person {
 }
 
 // Pass a Format object to get a codec for that format
-val jsonCodec: JsonBinaryCodec[Person] = Schema[Person].derive(JsonFormat)
+val jsonCodec: JsonCodec[Person] = Schema[Person].derive(JsonFormat)
 ```
 
 This works with any format:
@@ -151,12 +157,12 @@ object Person extends CompanionOptics[Person] {
 }
 
 // Override the codec for the "name" field
-val customNameCodec = new JsonBinaryCodec[String] {
+val customNameCodec = new JsonCodec[String] {
   def decodeValue(in: JsonReader): String = in.readString()
   def encodeValue(x: String, out: JsonWriter): Unit = out.writeVal(x.toUpperCase)
 }
 
-val codec: JsonBinaryCodec[Person] = Schema[Person]
+val codec: JsonCodec[Person] = Schema[Person]
   .deriving(JsonFormat.deriver)
   .instance(Person.name, customNameCodec)
   .derive
@@ -207,11 +213,11 @@ Passing a `Deriver` directly is useful when working with custom or configured de
 
 ## Convenience Methods on Format-Specific Codecs
 
-While the base `Codec` class defines only `encode(value, output)` and `decode(input)`, format-specific subclasses like `JsonBinaryCodec` and `ToonBinaryCodec` add convenience overloads for common I/O types.
+While the base `Codec` class defines only `encode(value, output)` and `decode(input)`, format-specific subclasses like `JsonCodec` and `ToonCodec` add convenience overloads for common I/O types.
 
-### JsonBinaryCodec Convenience Methods
+### JsonCodec Convenience Methods
 
-`JsonBinaryCodec[A]` provides the following overloads beyond the base `ByteBuffer` API:
+`JsonCodec[A]` provides the following overloads beyond the base `ByteBuffer` API:
 
 ```scala
 import zio.blocks.schema._
@@ -244,9 +250,9 @@ val is = new ByteArrayInputStream(os.toByteArray)
 val fromStream: Either[SchemaError, Person] = codec.decode(is)
 ```
 
-### ToonBinaryCodec Convenience Methods
+### ToonCodec Convenience Methods
 
-`ToonBinaryCodec[A]` provides the same set of overloads:
+`ToonCodec[A]` provides the same set of overloads:
 
 ```scala
 import zio.blocks.schema._
@@ -307,7 +313,7 @@ object Person {
   implicit val schema: Schema[Person] = Schema.derived
 }
 
-val customDeriver = JsonBinaryCodecDeriver
+val customDeriver = JsonCodecDeriver
   .withFieldNameMapper(NameMapper.SnakeCase)
   .withTransientNone(true)
   .withRejectExtraFields(true)
@@ -348,7 +354,7 @@ object Person {
   implicit val schema: Schema[Person] = Schema.derived
 }
 
-val customDeriver = ToonBinaryCodecDeriver
+val customDeriver = ToonCodecDeriver
   .withFieldNameMapper(NameMapper.SnakeCase)
   .withArrayFormat(ArrayFormat.Tabular)
   .withDiscriminatorKind(DiscriminatorKind.Field("type"))
@@ -365,11 +371,13 @@ import zio.blocks.schema._
 import zio.blocks.schema.json._
 
 case class Address(street: String, city: String)
-case class Person(name: String, address: Address)
 
 object Address {
   implicit val schema: Schema[Address] = Schema.derived
 }
+
+case class Person(name: String, address: Address)
+
 object Person {
   implicit val schema: Schema[Person] = Schema.derived
 }

package/reference/context.md

@@ -116,7 +116,7 @@ val config = ctx.get[Config]  // Compile-time proof it exists
 Add the ZIO Blocks Context module to your `build.sbt`:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-context" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-context" % "0.0.32"
 ```
 
 ## Construction
@@ -525,6 +525,22 @@ cd zio-blocks
 **Context construction: creating contexts with apply, empty.add, and inspecting size/isEmpty/nonEmpty**
 
 ```scala title="schema-examples/src/main/scala/context/ContextConstructionExample.scala" 
+/*
+ * Copyright 2024-2026 John A. De Goes and the ZIO Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package context
 
 import zio.blocks.context._
@@ -586,6 +602,22 @@ sbt "schema-examples/runMain context.ContextConstructionExample"
 **Context retrieval: using get, supertype lookups, and getOption for safe access**
 
 ```scala title="schema-examples/src/main/scala/context/ContextRetrievalExample.scala" 
+/*
+ * Copyright 2024-2026 John A. De Goes and the ZIO Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package context
 
 import zio.blocks.context._
@@ -655,6 +687,22 @@ sbt "schema-examples/runMain context.ContextRetrievalExample"
 **Context modification: adding values, updating existing ones, merging contexts, and pruning types**
 
 ```scala title="schema-examples/src/main/scala/context/ContextModificationExample.scala" 
+/*
+ * Copyright 2024-2026 John A. De Goes and the ZIO Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package context
 
 import zio.blocks.context._

package/reference/docs.md

@@ -10,7 +10,7 @@ Complete API reference for the zio-blocks-docs module - a zero-dependency GitHub
 ## Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-docs" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-docs" % "0.0.32"
 ```
 
 ## Core Types

package/reference/dynamic-schema.md

@@ -83,7 +83,7 @@ dynamic
 //         value = Primitive(
 //           primitiveType = String(None),
 //           typeId = String,
-//           primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@5b27ced8,
+//           primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@6cfd3324,
 //           doc = Doc(blocks = IndexedSeq(), metadata = Map()),
 //           modifiers = List(),
 //           storedDefaultValue = None,
@@ -97,7 +97,7 @@ dynamic
 //         value = Primitive(
 //           primitiveType = Int(None),
 //           typeId = Int,
-//           primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@5b27ced8,
+//           primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@6cfd3324,
 //           doc = Doc(blocks = IndexedSeq(), metadata = Map()),
 //           modifiers = List(),
 //           storedDefaultValue = None,
@@ -115,7 +115,7 @@ dynamic
 //               value = Primitive(
 //                 primitiveType = String(None),
 //                 typeId = String,
-//                 primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@5b27ced8,
+//                 primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@6cfd3324,
 //                 doc = Doc(blocks = IndexedSeq(), metadata = Map()),
 //                 modifiers = List(),
 //                 storedDefaultValue = None,

package/reference/formats.md

@@ -34,23 +34,27 @@ abstract class BinaryFormat[...](...) extends Format { ... }
 abstract class TextFormat[...](...) extends Format { ... }
 ```
 
-For example, the `JsonFormat` is a `BinaryFormat` that represents a JSON binary format, where the input for decoding is `ByteBuffer` and the output for encoding is also `ByteBuffer`, the MIME type is `application/json`, and the deriver for generating codecs from schemas is `JsonBinaryCodecDeriver`:
+For example, the `JsonFormat` is a `BinaryFormat` that represents a JSON binary format, where the input for decoding is `ByteBuffer` and the output for encoding is also `ByteBuffer`, the MIME type is `application/json`, and the deriver for generating codecs from schemas is `JsonCodecDeriver`:
 
 ```scala
-object JsonFormat extends BinaryFormat("application/json", JsonBinaryCodecDeriver)
+object JsonFormat extends BinaryFormat("application/json", JsonCodecDeriver)
 ```
 
 ## Built-in Formats
 
 Here's a summary of the formats currently supported by ZIO Blocks. Each format provides a `BinaryFormat` object that can be passed to `derive`:
 
-| Format Object       | Codec Type                  | MIME Type             | Module                          |
-|---------------------|-----------------------------|-----------------------|---------------------------------|
-| `JsonFormat`        | `JsonBinaryCodec[A]`        | `application/json`    | `zio-blocks-schema`             |
-| `ToonFormat`        | `ToonBinaryCodec[A]`        | `text/toon`           | `zio-blocks-schema-toon`        |
-| `MessagePackFormat` | `MessagePackBinaryCodec[A]` | `application/msgpack` | `zio-blocks-schema-messagepack` |
-| `AvroFormat`        | `AvroBinaryCodec[A]`        | `application/avro`    | `zio-blocks-schema-avro`        |
-| `ThriftFormat`      | `ThriftBinaryCodec[A]`      | `application/thrift`  | `zio-blocks-schema-thrift`      |
+| Format Object       | Codec Type            | MIME Type             | Module                          |
+|---------------------|-----------------------|-----------------------|---------------------------------|
+| `JsonFormat`        | `JsonCodec[A]`        | `application/json`    | `zio-blocks-schema`             |
+| `AvroFormat`        | `AvroCodec[A]`        | `application/avro`    | `zio-blocks-schema-avro`        |
+| `BsonFormat`        | `BsonCodec[A]`        | `application/bson`    | `zio-blocks-schema-bson`        |
+| `CsvFormat`         | `CsvCodec[A]`         | `text/csv`            | `zio-blocks-schema-csv`         |
+| `MessagePackFormat` | `MessagePackCodec[A]` | `application/msgpack` | `zio-blocks-schema-messagepack` |
+| `ThriftFormat`      | `ThriftCodec[A]`      | `application/thrift`  | `zio-blocks-schema-thrift`      |
+| `ToonFormat`        | `ToonCodec[A]`        | `text/toon`           | `zio-blocks-schema-toon`        |
+| `XmlFormat`         | `XmlCodec[A]`         | `application/xml`     | `zio-blocks-schema-xml`         |
+| `YamlFormat`        | `YamlCodec[A]`        | `application/yaml`    | `zio-blocks-schema-yaml`        |
 
 ## Defining a Custom Format
 
@@ -120,15 +124,9 @@ object Person {
   implicit val schema: Schema[Person] = Schema.derived
 }
 
-// Using JsonEncoder/JsonDecoder
-val jsonEncoder = JsonEncoder[Person]
-val jsonDecoder = JsonDecoder[Person]
-
 val person = Person("Alice", 30)
-val json: Json = jsonEncoder.encode(person)
-// {"name":"Alice","age":30}
-
-val decoded: Either[SchemaError, Person] = jsonDecoder.decode(json)
+val bytes: Array[Byte] = person.toJsonBytes
+val decoded: Either[SchemaError, Person] = bytes.fromJson[Person]
 ```
 
 ## Avro Format
@@ -168,7 +166,7 @@ val decoded: Either[SchemaError, Person] = codec.decode(bytes)
 
 ### Avro Schema Generation
 
-Each `AvroBinaryCodec` exposes an `avroSchema` property containing the Apache Avro schema:
+Each `AvroCodec` exposes an `avroSchema` property containing the Apache Avro schema:
 
 ```scala
 import zio.blocks.schema._
@@ -314,7 +312,7 @@ orders[2]{id,total}:
 
 ### Configuration Options
 
-The `ToonBinaryCodecDeriver` provides extensive configuration:
+The `ToonCodecDeriver` provides extensive configuration:
 
 ```scala
 import zio.blocks.schema._
@@ -326,7 +324,7 @@ object Person {
 }
 
 // Custom deriver with snake_case field names
-val customDeriver = ToonBinaryCodecDeriver
+val customDeriver = ToonCodecDeriver
   .withFieldNameMapper(NameMapper.SnakeCase)
   .withArrayFormat(ArrayFormat.Tabular)
   .withDiscriminatorKind(DiscriminatorKind.Field("type"))
@@ -368,7 +366,7 @@ val keyCodec = Schema[Shape].derive(ToonFormat)
 //   radius: 5
 
 // Field discriminator
-val fieldDeriver = ToonBinaryCodecDeriver
+val fieldDeriver = ToonCodecDeriver
   .withDiscriminatorKind(DiscriminatorKind.Field("type"))
 val fieldCodec = Schema[Shape].derive(fieldDeriver)
 // type: Circle

package/reference/json-schema.md

@@ -51,9 +51,9 @@ jsonSchema.conforms(valid)   // true
 jsonSchema.conforms(invalid) // false
 ```
 
-### Through JsonBinaryCodec
+### Through JsonCodec
 
-For more control, derive through `JsonBinaryCodec`:
+For more control, derive through `JsonCodec`:
 
 ```scala
 import zio.blocks.schema._

package/reference/json.md

@@ -531,69 +531,62 @@ val normalized = json.normalize
 
 ## Encoding and Decoding
 
-### Type Classes
-
-ZIO Blocks provides `JsonEncoder` and `JsonDecoder` type classes for converting between Scala types and `Json`:
+### Built-in Codecs
 
 ```scala
-import zio.blocks.schema.json.{Json, JsonEncoder, JsonDecoder}
+import zio.blocks.schema.Schema
 
-// Encode Scala values to Json
-val intJson = JsonEncoder[Int].encode(42)  // Json.Number(42)
-val strJson = JsonEncoder[String].encode("hello")  // Json.String("hello")
+// Primitives
+Schema[String].jsonCodec
+Schema[Int].jsonCodec
+Schema[Long].jsonCodec
+Schema[Double].jsonCodec
+Schema[Boolean].jsonCodec
+Schema[BigDecimal].jsonCodec
 
-// Decode Json to Scala values
-val intResult = JsonDecoder[Int].decode(Json.Number(42))  // Right(42)
-val strResult = JsonDecoder[String].decode(Json.String("hello"))  // Right("hello")
+// Collections
+Schema[List[Int]].jsonCodec
+Schema[Vector[String]].jsonCodec
+Schema[Map[String, Int]].jsonCodec
+Schema[Option[String]].jsonCodec
+
+// Java time/util types
+Schema[java.time.Instant].jsonCodec
+Schema[java.time.LocalDate].jsonCodec
+Schema[java.time.ZonedDateTime].jsonCodec
+Schema[java.util.UUID].jsonCodec
 ```
 
-### Built-in Encoders/Decoders
+### Encoding/Decoding of Primitives
 
 ```scala
-import zio.blocks.schema.json.{JsonEncoder, JsonDecoder}
-
-// Primitives
-JsonEncoder[String]
-JsonEncoder[Int]
-JsonEncoder[Long]
-JsonEncoder[Double]
-JsonEncoder[Boolean]
-JsonEncoder[BigDecimal]
+import zio.blocks.schema._
 
-// Collections
-JsonEncoder[List[Int]]
-JsonEncoder[Vector[String]]
-JsonEncoder[Map[String, Int]]
-JsonEncoder[Option[String]]
+// Encode Scala values to Json
+val intJson = 42.toJson  // Json.Number(42)
+val strJson = "hello".toJson  // Json.String("hello")
 
-// Java time types
-JsonEncoder[java.time.Instant]
-JsonEncoder[java.time.LocalDate]
-JsonEncoder[java.time.ZonedDateTime]
-JsonEncoder[java.util.UUID]
+// Decode Json to Scala values
+val intResult = intJson.as[Int]  // Right(42)
+val strResult = strJson.as[String]  // Right("hello")
 ```
 
-### Schema-Based Derivation
+### Encoding/Decoding of Case Classes
 
 For complex types, use Schema-based derivation:
 
 ```scala
-import zio.blocks.schema.Schema
-import zio.blocks.schema.json.{Json, JsonEncoder, JsonDecoder}
+import zio.blocks.schema._
 
 case class Person(name: String, age: Int)
 
 object Person {
   implicit val schema: Schema[Person] = Schema.derived
-  
-  // Derived from schema (lower priority)
-  implicit val encoder: JsonEncoder[Person] = JsonEncoder.fromSchema
-  implicit val decoder: JsonDecoder[Person] = JsonDecoder.fromSchema
 }
 
 val person = Person("Alice", 30)
-val json = JsonEncoder[Person].encode(person)
-val decoded = JsonDecoder[Person].decode(json)
+val json = person.toJson
+val decoded = json.as[Person]
 ```
 
 ### Extension Syntax
@@ -631,14 +624,12 @@ These extension methods provide a more ergonomic API compared to explicitly crea
 ### Using the `as` Method
 
 ```scala
-import zio.blocks.schema.json.Json
-import zio.blocks.schema.json.JsonDecoder
-import zio.blocks.schema.{Schema, SchemaError}
+import zio.blocks.schema._
+import zio.blocks.schema.json._
 
 case class Person(name: String, age: Int)
 object Person {
   implicit val schema: Schema[Person] = Schema.derived
-  implicit val decoder: JsonDecoder[Person] = JsonDecoder.fromSchema
 }
 
 val json = Json.parseUnsafe("""{"name": "Alice", "age": 30}""")

package/reference/media-type.md

@@ -75,13 +75,13 @@ textAny.matches(html) // true
 Add the following to your `build.sbt`:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-mediatype" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-mediatype" % "0.0.32"
 ```
 
 For cross-platform projects (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-mediatype" % "0.0.30"
+libraryDependencies += "dev.zio" %%% "zio-blocks-mediatype" % "0.0.32"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.

package/reference/modifier.md

@@ -38,9 +38,9 @@ object User extends CompanionOptics[User] {
     .derived[User]
     .modifier(Modifier.config("db.table-name", "users"))
 
-   implicit val jsonCodec: JsonBinaryCodec[User] =
+   implicit val jsonCodec: JsonCodec[User] =
      schema
-       .deriving(JsonBinaryCodecDeriver)
+       .deriving(JsonCodecDeriver)
        .modifier(User.name, Modifier.rename("username"))
        .modifier(User.cache, Modifier.transient())
        .derive
@@ -86,9 +86,9 @@ object User extends CompanionOptics[User] {
   implicit val schema: Schema[User] =
     Schema.derived[User]
 
-   implicit val jsonCodec: JsonBinaryCodec[User] =
+   implicit val jsonCodec: JsonCodec[User] =
      schema
-       .derive(JsonBinaryCodecDeriver)
+       .derive(JsonCodecDeriver)
 }
 ```
 

package/reference/resource-management/resource.md

@@ -36,13 +36,13 @@ Without Resources, managing complex initialization and cleanup is tedious and er
 Add the ZIO Blocks Scope module to your `build.sbt`:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.32"
 ```
 
 For cross-platform (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-scope" % "0.0.30"
+libraryDependencies += "dev.zio" %%% "zio-blocks-scope" % "0.0.32"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.

package/reference/resource-management/scope.md

@@ -55,7 +55,7 @@ If you've used `try/finally`, `Using`, or ZIO's `Scope`, this is the same proble
 Add the following dependency to your `build.sbt`:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.32"
 ```
 
 Supported Scala versions: **2.13.x** and **3.x**.

package/reference/resource-management/wire.md

@@ -92,13 +92,13 @@ Scope.global.scoped { scope =>
 Add the following dependency to your `build.sbt`:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.32"
 ```
 
 For cross-platform (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-scope" % "0.0.30"
+libraryDependencies += "dev.zio" %%% "zio-blocks-scope" % "0.0.32"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.
@@ -535,6 +535,22 @@ cd zio-blocks
 Basic wire construction demonstrates how to create and use `Wire` for dependency injection. View the example source code:
 
 ```scala title="scope-examples/src/main/scala/wire/WireBasicExample.scala" 
+/*
+ * Copyright 2024-2026 John A. De Goes and the ZIO Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package wire
 
 import zio.blocks.scope._
@@ -638,6 +654,22 @@ sbt "scope-examples/runMain wire.wireBasicExample"
 Comparing shared vs unique semantics shows how shared wires reuse the same instance across dependents, while unique wires create fresh instances. View the example:
 
 ```scala title="scope-examples/src/main/scala/wire/WireSharedUniqueExample.scala" 
+/*
+ * Copyright 2024-2026 John A. De Goes and the ZIO Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package wire
 
 import zio.blocks.scope._
@@ -743,6 +775,22 @@ sbt "scope-examples/runMain wire.wireSharedUniqueExample"
 Manual wire construction demonstrates how to use `fromFunction` for custom construction logic. View the example:
 
 ```scala title="scope-examples/src/main/scala/wire/WireFromFunctionExample.scala" 
+/*
+ * Copyright 2024-2026 John A. De Goes and the ZIO Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package wire
 
 import zio.blocks.scope._

package/reference/schema-error.md

@@ -539,7 +539,6 @@ Path annotation (`atField`, `atIndex`, `atKey`, `atCase`) builds a [`DynamicOpti
 ```scala
 import zio.blocks.schema.{DynamicOptic, DynamicValue, Schema, SchemaError}
 
-implicit val intSchema: Schema[Int] = Schema[Int]
 val data   = DynamicValue.Sequence(DynamicValue.int(1), DynamicValue.int(2))
 val optic  = DynamicOptic.root.at(10)
 

package/reference/schema-evolution/as.md

@@ -39,13 +39,13 @@ The bidirectional data flow looks like this:
 `As` is part of `zio-blocks-schema`:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.32"
 ```
 
 For Scala.js and Scala Native, use `%%%`:
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.32"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.
@@ -240,7 +240,7 @@ trait As[A, B] {
 
 ```scala
 val revAs: As[LongBox, IntBox] = boxAs.reverse
-// revAs: As[LongBox, IntBox] = zio.blocks.schema.As$$anon$1@c044a8b
+// revAs: As[LongBox, IntBox] = zio.blocks.schema.As$$anon$1@4bdeb475
 
 revAs.into(LongBox(5L))
 // res11: Either[SchemaError, IntBox] = Right(IntBox(5))
@@ -302,7 +302,7 @@ We import `As.reverseInto` and use it to obtain the reverse `Into[Int, String]`:
 import As.reverseInto
 
 val intToStr: Into[Int, String] = reverseInto[String, Int]
-// intToStr: Into[Int, String] = zio.blocks.schema.AsLowPriorityImplicits$$Lambda$17407/0x00007f6106975350@5d23723e
+// intToStr: Into[Int, String] = zio.blocks.schema.AsLowPriorityImplicits$$Lambda$17666/0x00007fd5f2a55c70@497d9813
 intToStr.into(42)
 // res14: Either[SchemaError, String] = Right("42")
 ```

package/reference/schema-evolution/into.md

@@ -69,13 +69,13 @@ Compare this to a manual implementation:
 `Into` is part of the `zio-blocks-schema` module:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.32"
 ```
 
 For Scala.js:
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.32"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.

package/reference/schema-expr.md

@@ -70,13 +70,13 @@ val result: Either[OpticCheck, Seq[Boolean]] = combined.eval(alice)
 ## Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.32"
 ```
 
 For cross-platform (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.30"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.32"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.

package/reference/schema.md

@@ -173,8 +173,6 @@ ZIO Blocks provides specialized `Option` schemas optimized for primitive types.
 ```scala
 import zio.blocks.schema.Schema
 
-import zio.blocks.schema.Schema
-
 // Specialized primitive options (no boxing overhead)
 Schema[Option[Boolean]]  // Also: Byte, Short, Int, Long, Float, Double, Char, Unit
 ```
@@ -193,12 +191,19 @@ Schema[Option[A]]  // Generic option for reference types
 ZIO Blocks also provides polymorphic schemas for standard Scala collections. You can summon schemas for collections of any element type `A` (and key/value types `K`/`V` for maps):
 
 ```scala
+import zio.blocks.schema.Schema
+
+// Built-in Scala collections
 Schema[List[A]]        // Immutable singly-linked list
 Schema[Vector[A]]      // Immutable indexed sequence (efficient random access)
 Schema[Set[A]]         // Immutable set (unique elements)
 Schema[Seq[A]]         // General immutable sequence
 Schema[IndexedSeq[A]]  // Indexed sequence
 Schema[Map[K, V]]      // Immutable key-value mapping
+
+// ZIO Blocks collections (the chunk module)
+Schema[zio.blocks.chunk.Chunk[A]]       // Chunk sequence
+Schema[zio.blocks.chunk.ChunkMap[K, V]] // ChunkMap key-value mapping
 ```
 
 To learn how to create custom collection schemas, check out the [`Sequence`](./reflect.md#3-sequence) and [`Map`](./reflect.md#4-map) nodes on the documentation of [`Reflect`](./reflect.md) data type.
@@ -358,13 +363,13 @@ In the following example, we derive a JSON codec for the `Person` case class usi
 
 ```scala
 import zio.blocks.schema.Schema
-import zio.blocks.schema.json.{JsonFormat, JsonBinaryCodec}
+import zio.blocks.schema.json.{JsonFormat, JsonCodec}
 
 case class Person(name: String, age: Int)
 
 object Person {
   implicit val schema: Schema[Person] = Schema.derived
-  val codec: JsonBinaryCodec[Person] = schema.derive(JsonFormat)
+  val codec: JsonCodec[Person] = schema.derive(JsonFormat)
 }
 
 val person = Person("John", 42)

package/reference/type-class-derivation.md

@@ -15,7 +15,7 @@ Consider a typical application with 50 domain types that needs 4 type classes (J
 
 Each instance requires understanding both the type's structure and the type class's semantics, then correctly implementing encoding, decoding, or whatever operation is required. This quickly becomes unmanageable as the codebase grows.
 
-Assume we have a simple `JsonCodec` type class for JSON serialization and deserialization:
+Assume we have a simple `JsonTC` type class for JSON serialization and deserialization:
 
 ```scala
 import zio.blocks.schema.json._
@@ -28,7 +28,7 @@ case class ParseError(details: String)
 case class DecodeError(details: String, path: String) 
   extends JsonError(s"Decode Error at '$path': $details")
 
-trait JsonCodec[A] {
+trait JsonTC[A] {
   def encode(a: A): Json
   def decode(j: Json): Either[JsonError, A]
 }
@@ -40,8 +40,8 @@ A single manual codec for a simple type like `Person` looks like the following c
 case class Person(name: String, age: Int)
 
 object Person {
-  implicit val personCodec: JsonCodec[Person] =
-    new JsonCodec[Person] {
+  implicit val personCodec: JsonTC[Person] =
+    new JsonTC[Person] {
       def encode(c: Person): Json = Json.obj(
         "name" -> Json.str(c.name),
         "age"  -> Json.number(c.age)
@@ -132,11 +132,11 @@ case class Schema[A](reflect: Reflect.Bound[A]) {
 }
 ```
 
-It takes a `Deriver[TC]` as a parameter and returns a type class instance of type `TC[A]`. For example, in the following code snippet, we derive a `JsonBinaryCodec[Person]` instance for the `Person` case class using the `JsonBinaryCodecDeriver`:
+It takes a `Deriver[TC]` as a parameter and returns a type class instance of type `TC[A]`. For example, in the following code snippet, we derive a `JsonCodec[Person]` instance for the `Person` case class using the `JsonCodecDeriver`:
 
 ```scala
 import zio.blocks.schema._
-import zio.blocks.schema.json.JsonBinaryCodecDeriver
+import zio.blocks.schema.json.JsonCodecDeriver
 
 case class Person(name: String, age: Int)
 
@@ -144,8 +144,7 @@ object Person {
   implicit val schema: Schema[Person] = Schema.derived[Person]
 }
 
-val jsonCodec: JsonBinaryCodec[Person] =
-  Person.schema.derive(JsonBinaryCodecDeriver)
+val jsonCodec: JsonCodec[Person] = Person.schema.derive(JsonCodecDeriver)
 
 val result: Either[SchemaError, Person] = 
   jsonCodec.decode(
@@ -1456,7 +1455,7 @@ Now we can use the derived `Gen[Person]` instance to generate random `Person` va
 
 ```scala
 val random = new Random(42) // Seeded for reproducible output
-// random: Random = scala.util.Random@2dde62c7
+// random: Random = scala.util.Random@195c6b05
 
 Person.gen.generate(random)
 // res14: Person = Person(name = "p", age = -1360544799)
@@ -1831,8 +1830,8 @@ object User extends CompanionOptics[User] {
 Now we can derive a JSON codec with custom modifiers, renaming fields and marking one as transient, without changing the schema itself:
 
 ```scala
-val jsonCodec: JsonBinaryCodec[User] = User.schema
-  .deriving(JsonBinaryCodecDeriver)
+val jsonCodec: JsonCodec[User] = User.schema
+  .deriving(JsonCodecDeriver)
   .modifier(User.name, Modifier.rename("full_name"))
   .modifier(User.email, Modifier.alias("mail"))
   .modifier(User.internalScore, Modifier.transient())
@@ -1861,8 +1860,8 @@ new String(jsonCodec.encode(user), "UTF-8")
 The `modifier` method with `TypeId` allows you to add a `Modifier.Reflect` to all schema nodes of a given type. This is useful for attaching format-specific configuration metadata to all occurrences of a type:
 
 ```scala
-val jsonCodec: JsonBinaryCodec[User] = User.schema
-  .deriving(JsonBinaryCodecDeriver)
+val jsonCodec: JsonCodec[User] = User.schema
+  .deriving(JsonCodecDeriver)
   .modifier(TypeId.of[User], Modifier.config("json", "camelCase"))
   .modifier(User.internalScore, Modifier.transient())
   .derive
@@ -1873,8 +1872,8 @@ val jsonCodec: JsonBinaryCodec[User] = User.schema
 The `modifier` method with `TypeId` and `termName` allows you to add a `Modifier.Term` to a specific field or case identified by name inside a parent type identified by its `TypeId`. This is useful when you want to target a specific term without constructing an optic for it. The `typeId` refers to the parent record/variant type that owns the term. If no term with the given name exists in the parent type, the modifier is silently ignored:
 
 ```scala
-val jsonCodec: JsonBinaryCodec[User] = User.schema
-  .deriving(JsonBinaryCodecDeriver)
+val jsonCodec: JsonCodec[User] = User.schema
+  .deriving(JsonCodecDeriver)
   .modifier(User.schema.reflect.typeId, "name", Modifier.rename("full_name"))
   .modifier(User.schema.reflect.typeId, "internalScore", Modifier.transient())
   .derive

package/reference/xml.md

@@ -942,9 +942,9 @@ All standard ZIO Blocks Schema types are supported:
 - Options (`Option[A]`)
 - Wrappers (newtypes)
 
-## XmlBinaryCodec
+## XmlCodec
 
-`XmlBinaryCodec[A]` is the low-level codec interface that bridges Schema definitions with XML serialization. While usually derived automatically, you can work with it directly:
+`XmlCodec[A]` is the low-level codec interface that bridges Schema definitions with XML serialization. While usually derived automatically, you can work with it directly:
 
 ```scala
 import zio.blocks.schema._
@@ -956,8 +956,7 @@ object Person {
 }
 
 // Get the underlying binary codec
-val codec: XmlBinaryCodec[Person] =
-  Schema[Person].derive(XmlBinaryCodecDeriver)
+val codec: XmlCodec[Person] = Schema[Person].derive(XmlCodecDeriver)
 
 // Encode to Xml directly
 val person = Person("Alice", 30)
@@ -967,7 +966,7 @@ val xml: Xml = codec.encodeValue(person)
 val decoded: Either[XmlError, Person] = codec.decodeValue(xml)
 ```
 
-**XmlBinaryCodec supports all Schema types:**
+**XmlCodec supports all Schema types:**
 - Primitives (Int, String, Boolean, etc.)
 - Java time types (Instant, LocalDate, Duration, etc.)
 - Records (case classes with field-level configuration)

package/ringbuffer.md

@@ -25,7 +25,7 @@ All variants expose `offer` (returns `false` if full) and `take` (returns `null`
 ## Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-ringbuffer" % "0.0.30"
+libraryDependencies += "dev.zio" %% "zio-blocks-ringbuffer" % "0.0.32"
 ```
 
 ---

package/undocumented-report.md

@@ -59,7 +59,7 @@ These are core public API types that users interact with directly. Each needs a
 **schema module — JSON subsystem:**
 - [ ] **`Keyable`** — Type class for JSON key support. Referenced in 5 files. **Scope: new section in json.md**. Source: `schema/shared/src/main/scala/zio/blocks/schema/json/Keyable.scala`
 - [ ] **`NameMapper`** (`CamelCase`, `KebabCase`, `PascalCase`) — Public field name transformations. **Scope: new section in json.md**. Source: `schema/shared/src/main/scala/zio/blocks/schema/json/NameMapper.scala`
-- [ ] **`JsonBinaryCodecError`** — Custom exception for JSON codec errors. Referenced in 7 files. **Scope: brief section in json.md**. Source: `schema/shared/src/main/scala/zio/blocks/schema/json/JsonBinaryCodecError.scala`
+- [ ] **`JsonCodecError`** — Custom exception for JSON codec errors. Referenced in 7 files. **Scope: brief section in json.md**. Source: `schema/shared/src/main/scala/zio/blocks/schema/json/JsonCodecError.scala`
 
 **typeid module:**
 - [ ] **`TypeRepr`** — Central type representation (24 subtypes: ThisType, TypeLambda, Singleton, Repeated, etc.). Referenced across 4-8 files each. **Scope: new section in typeid.md**. Source: `typeid/shared/src/main/scala/zio/blocks/typeid/TypeRepr.scala`
@@ -74,8 +74,8 @@ These are core public API types that users interact with directly. Each needs a
 
 **Format codec modules:**
 - [ ] **`BsonEncoder` / `BsonDecoder` / `BsonCodec`** (schema-bson) — Core encoding/decoding types for BSON. **Scope: expand formats.md BSON section**. Source: `schema-bson/src/main/scala/zio/blocks/schema/bson/BsonTypes.scala`
-- [ ] **`MessagePackBinaryCodec`** (schema-messagepack) — Public codec for MessagePack. **Scope: expand formats.md MessagePack section**. Source: `schema-messagepack/src/main/scala/zio/blocks/schema/msgpack/MessagePackBinaryCodec.scala`
-- [ ] **`ThriftBinaryCodec`** (schema-thrift) — Public codec for Thrift. **Scope: expand formats.md Thrift section**. Source: `schema-thrift/src/main/scala/zio/blocks/schema/thrift/ThriftBinaryCodec.scala`
+- [ ] **`MessagePackCodec`** (schema-messagepack) — Public codec for MessagePack. **Scope: expand formats.md MessagePack section**. Source: `schema-messagepack/src/main/scala/zio/blocks/schema/msgpack/MessagePackCodec.scala`
+- [ ] **`ThriftCodec`** (schema-thrift) — Public codec for Thrift. **Scope: expand formats.md Thrift section**. Source: `schema-thrift/src/main/scala/zio/blocks/schema/thrift/ThriftCodec.scala`
 - [ ] **`ToonReader` / `ToonWriter`** (schema-toon) — Public codec for TOON. Referenced in 9-10 files. **Scope: expand formats.md TOON section**. Source: `schema-toon/src/main/scala/zio/blocks/schema/toon/`
 
 **markdown module:**
@@ -244,7 +244,7 @@ Internal types that don't need documentation.
 | `Registry` / `Registry.Entry` | schema | Internal binding resolver storage |
 | `ObjectIdSupport` | schema-bson | Internal BSON ObjectId helper |
 | `BsonBuilder` / `BsonTrace` / `EncoderContext` / `BsonDecoderContext` | schema-bson | Internal codec implementation |
-| `MessagePackBinaryCodecDeriver` | schema-messagepack | Internal deriver |
+| `MessagePackCodecDeriver` | schema-messagepack | Internal deriver |
 | `MessagePackReader` / `MessagePackWriter` | schema-messagepack | Internal binary readers/writers |
 | `Mixed` / `UniformRecords` | schema-toon | Internal codec strategy types |
 | `ArrayHeader` | schema-toon | Internal reader state |
@@ -313,8 +313,8 @@ Ordered TODO checklist grouped by module, with estimated scope.
 ### Format modules (expand `formats.md`)
 
 26. - [ ] Expand **BSON section** in `formats.md` with BsonEncoder/BsonDecoder API — *update existing*
-27. - [ ] Expand **MessagePack section** in `formats.md` with MessagePackBinaryCodec API — *update existing*
-28. - [ ] Expand **Thrift section** in `formats.md` with ThriftBinaryCodec API — *update existing*
+27. - [ ] Expand **MessagePack section** in `formats.md` with MessagePackCodec API — *update existing*
+28. - [ ] Expand **Thrift section** in `formats.md` with ThriftCodec API — *update existing*
 29. - [ ] Expand **TOON section** in `formats.md` with ToonReader/ToonWriter, Delimiter, config — *update existing*
 
 ### Depth improvements (existing pages)