@zio.dev/zio-blocks 0.0.29 → 0.0.31

package/package.json

@@ -2,7 +2,7 @@
   "name": "@zio.dev/zio-blocks",
   "description": "ZIO Blocks Documentation",
   "license": "Apache-2.0",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "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 `ToonBinaryCodec[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:
 
@@ -33,7 +33,7 @@ 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)
+   implicit val codec: JsonCodec[Person] = schema.derive(JsonFormat)
 }
 
 // Encode
@@ -48,23 +48,23 @@ 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.29"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.31"
 ```
 
 Additional format modules are separate artifacts:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro"        % "0.0.29"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon"        % "0.0.29"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.29"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift"      % "0.0.29"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson"        % "0.0.29"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro"        % "0.0.31"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon"        % "0.0.31"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.31"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift"      % "0.0.31"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson"        % "0.0.31"
 ```
 
 For cross-platform projects (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.29"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.31"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.
@@ -76,7 +76,7 @@ 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]                    
+│   ├── JsonCodec[A]                    
 │   ├── AvroBinaryCodec[A]                   
 │   ├── ToonBinaryCodec[A]                  
 │   ├── ThriftBinaryCodec[A]               
@@ -116,7 +116,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 +151,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 +207,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 `ToonBinaryCodec` 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._
@@ -307,7 +307,7 @@ object Person {
   implicit val schema: Schema[Person] = Schema.derived
 }
 
-val customDeriver = JsonBinaryCodecDeriver
+val customDeriver = JsonCodecDeriver
   .withFieldNameMapper(NameMapper.SnakeCase)
   .withTransientNone(true)
   .withRejectExtraFields(true)

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.29"
+libraryDependencies += "dev.zio" %% "zio-blocks-context" % "0.0.31"
 ```
 
 ## 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.29"
+libraryDependencies += "dev.zio" %% "zio-blocks-docs" % "0.0.31"
 ```
 
 ## Core Types

package/reference/dynamic-schema.md

@@ -82,48 +82,45 @@ dynamic
 //         name = "name",
 //         value = Primitive(
 //           primitiveType = String(None),
-//           typeId = Impl(
-//             name = "String",
-//             owner = Owner(List(Package("java"), Package("lang"))),
-//             typeParams = List(),
-//             typeArgs = List(),
-//             defKind = Class(
-//               isFinal = true,
-//               isAbstract = false,
-//               isCase = false,
-//               isValue = false,
-//               bases = List(
-//                 Ref(
-//                   Impl(
-//                     name = "CharSequence",
-//                     owner = Owner(List(Package("java"), Package("lang"))),
-//                     typeParams = List(),
-//                     typeArgs = List(),
-//                     defKind = Trait(isSealed = false, bases = List()),
-//                     selfType = None,
-//                     aliasedTo = None,
-//                     representation = None,
-//                     annotations = List()
-//                   )
-//                 ),
-//                 Ref(
-//                   Impl(
-//                     name = "Comparable",
-//                     owner = Owner(List(Package("java"), Package("lang"))),
-//                     typeParams = List(
-//                       TypeParam(
-//                         name = "T",
-//                         index = 0,
-//                         variance = Invariant,
-//                         bounds = TypeBounds(lower = None, upper = None),
-//                         kind = Type
-//                       )
-//                     ),
-//                     typeArgs = List(),
-//                     defKind = Unknown,
-//                     selfType = None,
-//                     aliasedTo = None,
-//                     representation = None,
+//           typeId = String,
+//           primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@53d6fe60,
+//           doc = Doc(blocks = IndexedSeq(), metadata = Map()),
+//           modifiers = List(),
+//           storedDefaultValue = None,
+//           storedExamples = List()
+//         ),
+//         doc = Doc(blocks = IndexedSeq(), metadata = Map()),
+//         modifiers = List()
+//       ),
+//       Term(
+//         name = "age",
+//         value = Primitive(
+//           primitiveType = Int(None),
+//           typeId = Int,
+//           primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@53d6fe60,
+//           doc = Doc(blocks = IndexedSeq(), metadata = Map()),
+//           modifiers = List(),
+//           storedDefaultValue = None,
+//           storedExamples = List()
+//         ),
+//         doc = Doc(blocks = IndexedSeq(), metadata = Map()),
+//         modifiers = List()
+//       ),
+//       Term(
+//         name = "address",
+//         value = Record(
+//           fields = Vector(
+//             Term(
+//               name = "street",
+//               value = Primitive(
+//                 primitiveType = String(None),
+//                 typeId = String,
+//                 primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@53d6fe60,
+//                 doc = Doc(blocks = IndexedSeq(), metadata = Map()),
+//                 modifiers = List(),
+//                 storedDefaultValue = None,
+//                 storedExamples = List()
+//               ),
 // ...
 ```
 

package/reference/formats.md

@@ -34,10 +34,10 @@ 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
@@ -46,7 +46,7 @@ Here's a summary of the formats currently supported by ZIO Blocks. Each format p
 
 | Format Object       | Codec Type                  | MIME Type             | Module                          |
 |---------------------|-----------------------------|-----------------------|---------------------------------|
-| `JsonFormat`        | `JsonBinaryCodec[A]`        | `application/json`    | `zio-blocks-schema`             |
+| `JsonFormat`        | `JsonCodec[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`        |
@@ -120,15 +120,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

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.29"
+libraryDependencies += "dev.zio" %% "zio-blocks-mediatype" % "0.0.31"
 ```
 
 For cross-platform projects (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-mediatype" % "0.0.29"
+libraryDependencies += "dev.zio" %%% "zio-blocks-mediatype" % "0.0.31"
 ```
 
 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)
 }
 ```