@zio.dev/zio-blocks 0.0.51 → 0.0.55

package/reference/schema/built-in-codecs/toon.md

@@ -28,13 +28,13 @@ Rather than hand-writing TOON parsing logic or relying on external libraries wit
 Add the module to your `build.sbt`:
 
 ```sbt
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon" % "0.0.51"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon" % "0.0.55"
 ```
 
 For Scala.js, use `%%%` instead of `%%`:
 
 ```sbt
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema-toon" % "0.0.51"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema-toon" % "0.0.55"
 ```
 
 Supported Scala versions: 2.13.x and 3.x
@@ -325,7 +325,7 @@ object Person {
 }
 
 val codec = Person.schema.derive(ToonFormat)
-// codec: ToonCodec[Person] = zio.blocks.schema.toon.ToonCodecDeriver$$anon$5@3163694a
+// codec: ToonCodec[Person] = zio.blocks.schema.toon.ToonCodecDeriver$$anon$5@7c8849a3
 val person = Person("Alice", "alice@example.com")
 // person: Person = Person(name = "Alice", email = "alice@example.com")
 val bytes = codec.encode(person)

package/reference/schema/built-in-codecs/yaml.md

@@ -27,13 +27,13 @@ Rather than hand-writing YAML parsing logic or relying on external libraries wit
 Add the module to your `build.sbt`:
 
 ```sbt
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-yaml" % "0.0.51"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-yaml" % "0.0.55"
 ```
 
 For Scala.js, use `%%%` instead of `%%`:
 
 ```sbt
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema-yaml" % "0.0.51"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema-yaml" % "0.0.55"
 ```
 
 Supported Scala versions: 2.13.x and 3.x

package/reference/schema/codec.md

@@ -3,7 +3,7 @@ id: codec
 title: "Codec"
 ---
 
-`Codec[DecodeInput, EncodeOutput, Value]` is the base abstraction for encoding and decoding values between a specific input representation and a specific output representation. It forms the foundation of ZIO Blocks' multi-format serialization system, enabling a single `Schema[A]` to derive codecs for JSON, Avro, TOON, MessagePack, Thrift, and other formats that are integrated via the `Codec`/`Format` system. BSON support is provided separately via `BsonSchemaCodec`, which is not a subtype of `codec.Codec` and is not derived via `Schema.derive(format)`.
+`Codec[DecodeInput, EncodeOutput, Value]` is the base abstraction for encoding and decoding values between a specific input representation and a specific output representation. It forms the foundation of ZIO Blocks' multi-format serialization system, enabling a single `Schema[A]` to derive codecs for JSON, Avro, TOON, MessagePack, Thrift, and other formats integrated through `Codec`/`Format`. BSON's `BsonCodec` is not a subtype of `codec.Codec` because it operates on native `BsonReader`, `BsonWriter`, and `BsonValue` APIs. It nevertheless participates in shared type-class derivation through `Schema[A].derive(BsonCodecDeriver)`; `BsonSchemaCodec` remains a compatibility facade.
 
 ## Overview
 
@@ -48,26 +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.51"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.55"
 ```
 
 Additional format modules are separate artifacts:
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro"        % "0.0.51"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson"        % "0.0.51"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-csv"         % "0.0.51"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.51"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift"      % "0.0.51"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon"        % "0.0.51"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-xml"         % "0.0.51"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-yaml"        % "0.0.51"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro"        % "0.0.55"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson"        % "0.0.55"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-csv"         % "0.0.55"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.55"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift"      % "0.0.55"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon"        % "0.0.55"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-xml"         % "0.0.55"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-yaml"        % "0.0.55"
 ```
 
 For cross-platform projects (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.51"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.55"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.

package/reference/schema/dynamic-optic.md

@@ -398,7 +398,7 @@ val serialized: DynamicValue = opticSchema.toDynamicValue(path)
 
 ## Search Optics
 
-A **Search optic** recursively traverses a data structure to find **all occurrences** matching a type or schema. It produces a `Traversal[S, A]` that collects matches in depth-first, left-to-right order.
+A **Search optic** recursively traverses a data structure to find **all occurrences** matching a type or schema. It produces a `Traversal[S, A]` that collects matches in depth-first, left-to-right order. This section covers the two DSLs for building a search path; for the `SearchTraversal` engine that executes one — `fold`/`modify`/`check`, composing a search with other optics, and the `SchemaMatch` predicate behind `#Pattern` matching — see [Schema Search and Update](./schema-search.md).
 
 ### Motivation
 
@@ -483,6 +483,51 @@ val modified = data.modify(p"#string")(dv =>
 )
 ```
 
+### The `SchemaRepr` Pattern Type
+
+Every `#Pattern` string above parses into a `SchemaRepr` — a plain, immutable ADT you can also build by hand, independent of the interpolator. `DynamicOptic#searchSchema(schemaRepr)` takes one directly, and `Node.SchemaSearch(schemaRepr)` is the node it produces, exactly the node `#Pattern` syntax builds under the hood:
+
+```scala
+import zio.blocks.schema._
+
+val pattern: SchemaRepr = SchemaRepr.Record(
+  IndexedSeq("name" -> SchemaRepr.Primitive("string"), "age" -> SchemaRepr.Primitive("int"))
+)
+```
+
+`SchemaRepr#toString` renders the same syntax `#Pattern` strings use, so a pattern built by hand and one parsed from a literal print identically:
+
+```scala
+pattern.toString
+// res13: String = "record { name: string, age: int }"
+
+val path: DynamicOptic = DynamicOptic.root.searchSchema(pattern)
+// path: DynamicOptic = DynamicOptic(
+//   IndexedSeq(
+//     SchemaSearch(
+//       Record(Vector(("name", Primitive("string")), ("age", Primitive("int"))))
+//     )
+//   )
+// )
+path == p"#record { name: string, age: int }"
+// res14: Boolean = true
+```
+
+The eight cases cover every shape the grammar recognizes:
+
+| Case | Renders as | Matches |
+|------|------------|---------|
+| `Nominal(name)`         | the bare name, e.g. `Person`         | a value of that Scala type — only against a `Reflect` tree, see below |
+| `Primitive(name)`       | the bare name, e.g. `string`         | a primitive of that kind (case-insensitive) |
+| `Record(fields)`        | `record { name: string, ... }`       | a record with at least those fields, by subset match |
+| `Variant(cases)`        | `variant { Case: type, ... }`        | a variant whose active case matches one of those entries |
+| `Sequence(element)`     | `list(...)`                          | a sequence whose elements all match — parses from `list(...)`, `set(...)`, or `vector(...)`, all three producing the same case |
+| `Map(key, value)`       | `map(key, value)`                    | a map whose entries all match both patterns |
+| `Optional(inner)`       | `option(...)`                        | `Null`, or a value matching the inner pattern |
+| `Wildcard`              | `_`                                   | anything |
+
+Parsing a `#Pattern` string is itself layered: the path interpolator recognizes the `#` prefix and hands the substring after it to a small recursive-descent parser, which reports a specific error (unexpected character, an empty `record {}`/`variant {}`, an unterminated expression) at the exact offset where parsing failed — that's what turns a typo like `#record { name: strnig }` into a compile-time interpolator error rather than a pattern that silently matches nothing.
+
 ### Supported Patterns
 
 Search optics support both **type-based** and **schema-based** patterns:
@@ -493,7 +538,7 @@ Search optics support both **type-based** and **schema-based** patterns:
 | `#int`, `#string`, `#boolean`  | Specific primitive types (case-insensitive) | `#int`, `#string`, `#boolean` |
 | `#record { ... }`              | Records with matching fields           | `#record { name: string }` |
 | `#variant { ... }`             | Variant cases with matching content    | `#variant { Error: string }` |
-| `#list(...)`                   | Lists/sequences with element type     | `#list(string)`            |
+| `#list(...)`, `#set(...)`, `#vector(...)` | Sequences with a matching element type, regardless of which of the three keywords appears | `#list(string)` |
 | `#map(...)`                    | Maps with key and value types          | `#map(string, int)`        |
 | `#option(...)`                 | Optional values with inner type       | `#option(int)`             |
 
@@ -520,7 +565,7 @@ val allInts = nested.get(p"#int").toChunk
 
 ### Known Limitation: Nominal Matching in Untyped Contexts
 
-`Nominal` pattern matching (e.g., `#Person`) returns `false` when applied to `DynamicValue` or `Json` because these untyped structures carry no type identity. To match nominally-typed data, use one of these approaches:
+`Nominal` pattern matching (e.g., `#Person`) returns `false` against a `DynamicValue` or `Json` value because these untyped structures carry no type identity. The one exception is searching a `Schema`/`Reflect` tree itself (as `DynamicSchema#get` does) rather than a value — there, `Nominal` matches by comparing against the tree's own `TypeId`, since a `Reflect` node still carries the type identity a plain `DynamicValue`/`Json` value never does. For searching values, use one of these approaches instead:
 
 - **Use the typed API**: `optic(_.searchFor[Person])`
 - **Or use structural patterns**: `p"#record { name: string, age: int }"`

package/reference/schema/dynamic-schema.md

@@ -83,7 +83,7 @@ dynamic
 //         value = Primitive(
 //           primitiveType = String(None),
 //           typeId = String,
-//           primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@480c1083,
+//           primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@5fb4c2ef,
 //           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@480c1083,
+//           primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@5fb4c2ef,
 //           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@480c1083,
+//                 primitiveBinding = zio.blocks.schema.binding.NoBinding$$anon$1@5fb4c2ef,
 //                 doc = Doc(blocks = IndexedSeq(), metadata = Map()),
 //                 modifiers = List(),
 //                 storedDefaultValue = None,

package/reference/schema/index.md

@@ -12,6 +12,7 @@ ZIO Blocks Schema is the core type system and serialization framework that provi
 - [`Schema`](./schema.md) — Primary data type containing reified structure of a Scala data type
 - [`Reflect`](./reflect.md) — Foundational data structure containing reified structural information
 - [`Binding`](./binding.md) — Operational machinery for constructing and deconstructing values
+- [`ReflectTransformer`](./reflect-transformer.md) — Generic mechanism for rewriting a Reflect tree's binding type, powering schema (de)serialization and derivation
 - [`Registers`](./registers.md) — Register-based design for zero-allocation construction and deconstruction
 - [`Structural Types`](./structural-types.md) — Duck typing with ZIO Blocks schemas
 
@@ -24,6 +25,7 @@ ZIO Blocks Schema is the core type system and serialization framework that provi
 - [`Optics`](./optics.md) — Reflective optics for type-safe, composable access to nested data structures
 - [`DynamicOptic`](./dynamic-optic.md) — Runtime path through nested data structures
 - [`Path Interpolator`](./path-interpolator.md) — Compile-time string interpolator `p"..."` for constructing `DynamicOptic` instances
+- [`Schema Search and Update`](./schema-search.md) — Executing type/schema-pattern searches with `SearchTraversal`, and rewriting schema metadata with `Reflect.Updater`/`Term.Updater`
 - [`SchemaExpr`](./schema-expr.md) — Schema-aware expressions for evaluation and query language translation
 - [`Patch`](./patch.md) — Type-safe, serializable transformations of data structures
 - [`Modifier`](./modifier.md) — Mechanism to attach metadata and configuration to schema elements

package/reference/schema/path-interpolator.md

@@ -267,6 +267,8 @@ p"#map(string, int)"                       // Find maps from string to int
 p"#option(Person)"                         // Find optional Person values
 ```
 
+`set(...)` and `vector(...)` work as synonyms for `list(...)` — all three parse to the same `SchemaRepr.Sequence` pattern, since the pattern only cares about the element type, not which collection it comes from.
+
 To match any value regardless of type:
 
 ```scala

package/reference/schema/reflect-transformer.md

@@ -0,0 +1,140 @@
+---
+id: reflect-transformer
+title: "ReflectTransformer"
+---
+
+`ReflectTransformer[F, G]` rewrites a `Reflect[F, A]` tree into a `Reflect[G, A]` tree, changing the binding-metadata type constructor from `F` to `G` at every node while leaving the shape — field names, type IDs, docs, modifiers, defaults, examples — untouched. `Reflect#transform` walks the tree and recurses into fields, cases, elements, and keys/values for you; a `ReflectTransformer` only has to say how to rebuild the metadata-bearing leaf of each node kind once its children are already transformed.
+
+Three things in the codebase are built on it: stripping bindings to serialize a [`Schema`](./schema.md) as a [`DynamicSchema`](./dynamic-schema.md), attaching bindings back with `RebindTransformer`, and [type class derivation](./type-class-derivation.md), which pairs each node's binding with a derived instance. This page covers all three, plus `OnlyMetadata`, the base class most transformers use instead of implementing the full interface.
+
+## Design & Structure
+
+`ReflectTransformer` declares one method per [`Reflect`](./reflect.md) node kind — seven of the eight; `Deferred` is handled separately (see [Cycle Safety](#cycle-safety-and-the-transform-cache)) because it has no metadata of its own to transform. `transformRecord` is representative of all seven — each takes the node's already-transformed children plus its untouched shape fields, and returns a `Lazy` of the rebuilt node:
+
+```scala
+trait ReflectTransformer[-F[_, _], G[_, _]] {
+  def transformRecord[A](
+    path: DynamicOptic,
+    fields: IndexedSeq[Term[G, A, ?]],
+    typeId: TypeId[A],
+    metadata: F[BindingType.Record, A],
+    doc: Doc,
+    modifiers: Seq[Modifier.Reflect],
+    storedDefaultValue: Option[DynamicValue],
+    storedExamples: collection.immutable.Seq[DynamicValue]
+  ): Lazy[Reflect.Record[G, A]]
+
+  // ...one more method per remaining node kind, same shape
+}
+```
+
+The other six follow the identical pattern — a `path`, the already-transformed children, the shape fields, and the still-untransformed `metadata: F[...]` — differing only in which children they carry and which `Reflect` node they return:
+
+| Node kind | Method | Transformed children it receives |
+| ---------- | -------- | ----------------------------------- |
+| `Record`     | `transformRecord`    | `fields: IndexedSeq[Term[G, A, ?]]` |
+| `Variant`    | `transformVariant`   | `cases: IndexedSeq[Term[G, A, ? <: A]]` |
+| `Sequence`   | `transformSequence`  | `element: Reflect[G, A]` |
+| `Map`        | `transformMap`       | `key: Reflect[G, Key]`, `value: Reflect[G, Value]` |
+| `Dynamic`    | `transformDynamic`   | none — `DynamicValue` has no children |
+| `Primitive`  | `transformPrimitive` | none |
+| `Wrapper`    | `transformWrapper`   | `wrapped: Reflect[G, B]` |
+
+Every result is wrapped in [`Lazy`](./lazy.md) because a transformer built for a recursive schema must be able to build a node before its own children are fully forced.
+
+## `OnlyMetadata` — The Common Case
+
+Most transformers only need to change the metadata and leave every field, case, and element exactly as it already was. `ReflectTransformer.OnlyMetadata[F, G]` implements all seven `transformX` methods for you in terms of one method:
+
+```scala
+abstract class OnlyMetadata[F[_, _], G[_, _]] extends ReflectTransformer[F, G] {
+  def transformMetadata[K, A](f: F[K, A]): Lazy[G[K, A]]
+}
+```
+
+Each `transformX` implementation `OnlyMetadata` provides is one line: transform the metadata, then rebuild the same node with the same children and shape, swapping in the new metadata. `HasBinding[F]` — the type class that extracts a `Binding[T, A]` out of an arbitrary `F[T, A]` — is itself a `ReflectTransformer.OnlyMetadata[F, Binding]` whose `transformMetadata` calls the one method a `HasBinding[F]` instance supplies.
+
+## Stripping Bindings: `ReflectTransformer.noBinding`
+
+`ReflectTransformer.noBinding[F]()` is a predefined, stateless transformer that discards whatever metadata `F` holds and replaces it with the singleton `NoBinding` value, regardless of what `F` was. It is what `Reflect#noBinding` and, through it, `Schema#toDynamicSchema` use to turn a bound, operational schema into a pure-data one safe to serialize:
+
+```scala
+import zio.blocks.schema._
+
+case class Person(name: String, age: Int)
+object Person {
+  implicit val schema: Schema[Person] = Schema.derived
+}
+
+// Reflect.Bound[Person] -> Reflect.Unbound[Person], via ReflectTransformer.noBinding()
+val unbound: Reflect.Unbound[Person] = Person.schema.reflect.noBinding
+
+// The public entry point most code uses instead
+val dynamicSchema: DynamicSchema = Person.schema.toDynamicSchema
+```
+
+Because `ReflectTransformer.noBinding` never inspects the metadata it's replacing, one singleton instance (cast per call) serves every `F`, with no allocation per use.
+
+## Attaching Bindings: `RebindTransformer`
+
+`RebindTransformer` is the transformer in the opposite direction — `NoBinding` to `Binding` — that [`DynamicSchema#rebind`](./dynamic-schema.md) constructs internally to turn a deserialized, pure-data schema back into an operational one. It is `private[schema]`; the public surface is `DynamicSchema#rebind`, which builds one for you from a [`BindingResolver`](./binding-resolver.md):
+
+```scala
+import zio.blocks.schema._
+import zio.blocks.schema.binding._
+
+case class Person(name: String, age: Int)
+object Person {
+  implicit val schema: Schema[Person] = Schema.derived
+}
+
+val dynamicSchema: DynamicSchema = Person.schema.toDynamicSchema
+
+val resolver = BindingResolver.defaults.bind(Binding.of[Person])
+val rebound: Schema[Person] = dynamicSchema.rebind[Person](resolver)
+```
+
+Unlike `ReflectTransformer.noBinding`, `RebindTransformer` implements every `transformX` method individually rather than extending `OnlyMetadata` — each one must call a different resolver lookup (`resolveRecord`, `resolveVariant`, `resolveSeqFor`, `resolveMapFor`, `resolveDynamic`, `resolvePrimitive`, `resolveWrapper`) and fail in a way that names which kind of binding was missing.
+
+### `RebindException`
+
+A resolver that's missing a binding for some type in the tree makes `DynamicSchema#rebind` throw `RebindException` rather than return quietly, since a `Schema` with an unresolved node isn't safe to hand back:
+
+```scala
+import zio.blocks.schema._
+import zio.blocks.schema.binding._
+
+case class Person(name: String, age: Int)
+object Person {
+  implicit val schema: Schema[Person] = Schema.derived
+}
+
+val dynamicSchema = Person.schema.toDynamicSchema
+
+try dynamicSchema.rebind[Person](BindingResolver.empty)
+catch {
+  case e: RebindException =>
+    // path: the DynamicOptic where the lookup failed
+    // typeId: the missing type
+    // expectedKind: "Record", "Variant", "Sequence", "Map", "Dynamic", "Primitive", or "Wrapper"
+    println(s"${e.expectedKind} binding missing for ${e.typeId.fullName} at ${e.path}")
+}
+```
+
+## Writing a Full `ReflectTransformer`: Type Class Derivation
+
+`OnlyMetadata` covers every transformer described so far, but the interface exists in full for a reason: automatic type class derivation implements every `transformX` method directly, because deriving an instance for a `Record` needs the already-derived instances of its *fields*, not just a metadata swap. `DerivationBuilder.derive` walks a bound schema with a custom `ReflectTransformer[Binding, BindingInstance[TC, ?, ?]]` that, at each node, either substitutes a user-supplied override or invokes a [`Deriver[TC]`](./type-class-derivation.md) with the node's already-transformed children, then pairs the result with the original binding. This is the pattern to reach for when a transformation genuinely depends on more than the metadata at a single node.
+
+## Cycle Safety and the Transform Cache
+
+A recursive schema — one whose `Reflect` tree refers back to itself — reaches that self-reference through a `Reflect.Deferred` node. `Deferred#transform` doesn't call any `transformX` method; it looks up the pair `(this Deferred, this transformer)` in a per-thread memoization map first, and only builds a new deferred node on a miss. This is what makes `Reflect#transform` terminate on a recursive schema, and what lets a `Deferred` reached through multiple paths share one transformed result instead of being rebuilt repeatedly.
+
+The two public entry points — `Reflect#noBinding` and `DynamicSchema#rebind` — wrap their call in an internal scope that clears this cache once the outermost `Reflect#transform` finishes, so a transformer's captured state (override maps, resolvers) doesn't stay pinned on the thread once its call returns. Reaching either entry point is enough to get this for free; it isn't something you configure.
+
+## See Also
+
+- [Reflect](./reflect.md) — the tree `ReflectTransformer` rewrites, and its eight node kinds
+- [Binding](./binding.md) — what `F`/`G` are in practice: `Binding` and `NoBinding`
+- [BindingResolver](./binding-resolver.md) — the lookup `RebindTransformer` delegates to
+- [DynamicSchema](./dynamic-schema.md) — `Schema#toDynamicSchema` and `DynamicSchema#rebind`, the public entry points
+- [Type Class Derivation](./type-class-derivation.md) — the fullest real use of the interface

package/reference/schema/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.51"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.55"
 ```
 
 For Scala.js and Scala Native, use `%%%`:
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.51"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.55"
 ```
 
 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@29c128e0
+// revAs: As[LongBox, IntBox] = zio.blocks.schema.As$$anon$1@50968506
 
 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$19927/0x00007f2996e03990@597c011
+// intToStr: Into[Int, String] = zio.blocks.schema.AsLowPriorityImplicits$$Lambda/0x0000000027f8bc38@794d4993
 intToStr.into(42)
 // res14: Either[SchemaError, String] = Right("42")
 ```

package/reference/schema/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.51"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.55"
 ```
 
 For Scala.js:
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.51"
+libraryDependencies += "dev.zio" %%% "zio-blocks-schema" % "0.0.55"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.

package/reference/schema/schema-expr.md

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