@zio.dev/zio-blocks 0.0.1 → 0.0.21

package/index.md

@@ -5,7 +5,7 @@ title: "ZIO Blocks"
 
 **Modular, zero-dependency building blocks for modern Scala applications.**
 
-@PROJECT_BADGES@
+[![Development](https://img.shields.io/badge/Project%20Stage-Development-green.svg)](https://github.com/zio/zio/wiki/Project-Stages) ![CI Badge](https://github.com/zio/zio-blocks/workflows/CI/badge.svg) [![Sonatype Releases](https://img.shields.io/nexus/r/https/oss.sonatype.org/dev.zio/zio-blocks-next-schema_3.svg?label=Sonatype%20Release)](https://oss.sonatype.org/content/repositories/releases/dev/zio/zio-blocks-next-schema_3/) [![Sonatype Snapshots](https://img.shields.io/nexus/s/https/oss.sonatype.org/dev.zio/zio-blocks-next-schema_3.svg?label=Sonatype%20Snapshot)](https://oss.sonatype.org/content/repositories/snapshots/dev/zio/zio-blocks-next-schema_3/) [![javadoc](https://javadoc.io/badge2/dev.zio/zio-blocks-docs_3/javadoc.svg)](https://javadoc.io/doc/dev.zio/zio-blocks-docs_3) [![ZIO Blocks](https://img.shields.io/github/stars/zio/zio-blocks?style=social)](https://github.com/zio/zio-blocks)
 
 ## What Is ZIO Blocks?
 
@@ -19,6 +19,7 @@ The philosophy is simple: **use what you need, nothing more**. Each block is ind
 |-------|-------------|--------|
 | **Schema** | Type-safe schemas with automatic codec derivation | ✅ Available |
 | **Chunk** | High-performance immutable indexed sequences | ✅ Available |
+| **Scope** | Compile-time safe resource management and DI | ✅ Available |
 | **Docs** | GitHub Flavored Markdown parsing and rendering | ✅ Available |
 | **TypeId** | Compile-time type identity with rich metadata | ✅ Available |
 | **Context** | Type-indexed heterogeneous collections | ✅ Available |
@@ -79,14 +80,14 @@ val thriftCodec  = Schema[Person].derive(ThriftFormat)      // Thrift
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "@VERSION@"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema" % "0.0.21"
 
 // Optional format modules:
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro" % "@VERSION@"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon" % "@VERSION@"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "@VERSION@"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift" % "@VERSION@"
-libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson" % "@VERSION@"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-avro" % "0.0.21"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-toon" % "0.0.21"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-messagepack" % "0.0.21"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-thrift" % "0.0.21"
+libraryDependencies += "dev.zio" %% "zio-blocks-schema-bson" % "0.0.21"
 ```
 
 ### Example: Optics
@@ -141,7 +142,7 @@ Chunk is designed for:
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-chunk" % "@VERSION@"
+libraryDependencies += "dev.zio" %% "zio-blocks-chunk" % "0.0.21"
 ```
 
 ### Example
@@ -170,6 +171,132 @@ val head: Int = nonEmpty.head  // Always safe, no Option needed
 
 ---
 
+## Scope
+
+Compile-time verified resource safety for synchronous Scala code. Scope prevents resource leaks at compile time by tagging values with an unnameable type-level identity—values allocated in a scope can only be used within that scope, and child scope values cannot escape to parent scopes.
+
+### The Problem
+
+Resource management in Scala is error-prone:
+
+```scala
+// Classic try/finally - verbose and easy to get wrong
+val db = openDatabase()
+try {
+  val tx = db.beginTransaction()
+  try {
+    doWork(tx)
+    tx.commit()
+  } finally tx.close()  // What if commit() throws?
+} finally db.close()
+
+// Using - better, but doesn't prevent returning resources
+Using(openDatabase()) { db =>
+  db  // Oops! Returned the resource - use after close!
+}
+```
+
+### The Solution
+
+Scope makes resource leaks a **compile error**, not a runtime bug:
+
+```scala
+import zio.blocks.scope._
+
+Scope.global.scoped { scope =>
+  val db: Database @@ scope.Tag = scope.allocate(Resource(openDatabase()))
+
+  // Methods are hidden - can't call db.query() directly
+  // Must use scope $ to access:
+  val result = (scope $ db)(_.query("SELECT 1"))
+
+  // Trying to return `db` would be a compile error!
+  result  // Only pure data escapes
+}
+// db.close() called automatically
+```
+
+### Key Features
+
+- **Compile-Time Leak Prevention**: Values tagged with `A @@ S` can only be used with proof of scope access. Returning a scoped value from its scope is a type error.
+- **Zero Runtime Overhead**: On the eager path the `@@` tag is erased—`A @@ S` is represented as just `A` when evaluated—while deferred/composed computations use a small wrapper/thunk.
+- **Structured Scopes**: Child scopes nest within parents; resources clean up LIFO when scopes exit.
+- **Built-in Dependency Injection**: Wire up your application with `Resource.from[T](wires*)` for automatic constructor-based DI.
+- **AutoCloseable Integration**: Resources implementing `AutoCloseable` have `close()` registered automatically.
+
+### Installation
+
+```scala
+libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.21"
+```
+
+### Example: Basic Resource Management
+
+```scala
+import zio.blocks.scope._
+
+final class Database extends AutoCloseable {
+  def query(sql: String): String = s"Result: $sql"
+  def close(): Unit = println("Database closed")
+}
+
+Scope.global.scoped { scope =>
+  // Allocate returns Database @@ scope.Tag (scoped value)
+  val db = scope.allocate(Resource(new Database))
+
+  // Access via scope $ - result (String) escapes, db does not
+  val result = (scope $ db)(_.query("SELECT * FROM users"))
+  println(result)
+}
+// Output: Result: SELECT * FROM users
+//         Database closed
+```
+
+### Example: Dependency Injection
+
+```scala
+import zio.blocks.scope._
+
+case class Config(dbUrl: String)
+class Database(config: Config) extends AutoCloseable { ... }
+class UserRepo(db: Database) { ... }
+class UserService(repo: UserRepo) extends AutoCloseable { ... }
+
+// Resource.from auto-wires the dependency graph
+// Only provide leaf values - concrete classes are auto-wired
+val serviceResource: Resource[UserService] = Resource.from[UserService](
+  Wire(Config("jdbc:postgresql://localhost/mydb"))
+)
+
+Scope.global.scoped { scope =>
+  val service = scope.allocate(serviceResource)
+  (scope $ service)(_.createUser("Alice"))
+}
+// Cleanup runs LIFO: UserService → Database (UserRepo has no cleanup)
+```
+
+### Example: Nested Scopes with Transactions
+
+```scala
+Scope.global.scoped { connScope =>
+  val conn = connScope.allocate(Resource.fromAutoCloseable(new Connection))
+
+  // Transaction lives in child scope - cleaned up before connection
+  val result = connScope.scoped { txScope =>
+    val tx = txScope.allocate(conn.beginTransaction())  // Returns Resource!
+    (txScope $ tx)(_.execute("INSERT INTO users VALUES (1, 'Alice')"))
+    (txScope $ tx)(_.commit())
+    "success"
+  }
+  // Transaction closed here, connection still open
+
+  println(result)
+}
+// Connection closed here
+```
+
+---
+
 ## Docs
 
 A zero-dependency GitHub Flavored Markdown library for parsing, rendering, and programmatic construction of Markdown documents.
@@ -194,7 +321,7 @@ Generating documentation, README files, or any Markdown content programmatically
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-docs" % "@VERSION@"
+libraryDependencies += "dev.zio" %% "zio-blocks-docs" % "0.0.21"
 ```
 
 ### Example
@@ -278,7 +405,7 @@ Compile-time type identity with rich metadata. TypeId captures comprehensive inf
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-typeid" % "@VERSION@"
+libraryDependencies += "dev.zio" %% "zio-blocks-typeid" % "0.0.21"
 ```
 
 ### Example
@@ -321,7 +448,7 @@ A type-indexed heterogeneous collection that stores values by their types with c
 ### Installation
 
 ```scala
-libraryDependencies += "dev.zio" %% "zio-blocks-context" % "@VERSION@"
+libraryDependencies += "dev.zio" %% "zio-blocks-context" % "0.0.21"
 ```
 
 ### Example
@@ -385,10 +512,10 @@ Each block has zero dependencies on effect systems. Use the blocks directly, or
 
 ZIO Blocks supports **Scala 2.13** and **Scala 3.x** with full source compatibility. Write your code once and compile it against either version—migrate to Scala 3 when your team is ready, not when your dependencies force you.
 
-| Platform | Schema | Chunk | Docs | TypeId | Context | Streams |
-|----------|--------|-------|------|--------|---------|---------|
-| JVM | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Scala.js | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Platform | Schema | Chunk | Scope | Docs | TypeId | Context | Streams |
+|----------|--------|-------|-------|------|--------|---------|---------|
+| JVM | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Scala.js | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 
 ## Documentation
 
@@ -421,6 +548,7 @@ ZIO Blocks supports **Scala 2.13** and **Scala 3.x** with full source compatibil
 ### Other Blocks
 
 - [Chunk](./reference/chunk.md) - High-performance immutable sequences
+- [Scope](./scope.md) - Compile-time safe resource management and DI
 - [TypeId](./reference/typeid.md) - Type identity and metadata
 - [Context](./reference/context.md) - Type-indexed heterogeneous collections
 - [Docs (Markdown)](./reference/docs.md) - Markdown parsing and rendering

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@zio.dev/zio-blocks",
-  "version": "0.0.1",
   "description": "ZIO Blocks Documentation",
-  "license": "Apache-2.0"
+  "license": "Apache-2.0",
+  "version": "0.0.21",
+  "repository": {
+    "url": "https://github.com/zio/zio-blocks"
+  }
 }

package/reference/binding.md

@@ -66,7 +66,7 @@ final case class Record[A](
 
 Here is an example of a `Binding.Record` for a simple `Person` case class:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.binding._
 import zio.blocks.schema.binding.RegisterOffset._
 
@@ -115,13 +115,11 @@ final case class Variant[A](
 - `Discriminator`: Given a value of a sum type, determine which case it belongs to by returning a numerical index.
 - `Matchers`: Given a value and a case index, safely downcast the value to the specific case type, or return null if it doesn't match.
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema.binding._
 
 sealed trait Shape extends Product with Serializable
-
 case class Circle(radius: Double) extends Shape
-
 case class Rectangle(width: Double, height: Double) extends Shape
 
 val shapeBinding = Binding.Variant[Shape](
@@ -302,25 +300,21 @@ final case class Wrapper[A, B](
 
 **Components:**
 
-- `wrap`: Converts from the underlying type `B` to the wrapper type `A`, returning `Right(a)` on success or `Left(SchemaError)` on failure
-- `unwrap`: Extracts the underlying `B` from an `A`, returning `Right(b)` on success or `Left(SchemaError)` on failure
+- `wrap`: Converts from the underlying type `B` to the wrapper type `A`
+- `unwrap`: Extracts the underlying `B` from an `A`
 
-Here is an example of a `Binding.Wrapper` for an `Email` newtype with validation:
+Here is an example of a `Binding.Wrapper` for an `Email` newtype:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.schema._
 import zio.blocks.schema.binding._
 
 case class Email(value: String)
 
 object Email {
-  private val EmailRegex = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$".r
   new Binding.Wrapper[Email, String](
-    wrap = {
-      case x@EmailRegex(_*) => Right(new Email(x))
-      case _ => Left(SchemaError.validationFailed("Expected valid email format"))
-    },
-    email => Right(email.value)
+    wrap = value => new Email(value),
+    unwrap = email => email.value
   )
 }
 ```

package/reference/chunk.md

@@ -46,7 +46,7 @@ Supported Scala versions: 2.13.x and 3.x
 
 ### From Varargs
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val numbers = Chunk(1, 2, 3, 4, 5)
@@ -56,7 +56,7 @@ val empty   = Chunk.empty[Int]
 
 ### From a Single Element
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val single = Chunk.single(42)
@@ -67,7 +67,7 @@ val unit   = Chunk.unit // Chunk(())
 
 When you have an existing array, use `fromArray`. Note that the array should not be mutated after wrapping:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val arr   = Array(1, 2, 3)
@@ -76,7 +76,7 @@ val chunk = Chunk.fromArray(arr)
 
 ### From Iterables and Iterators
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val fromList   = Chunk.fromIterable(List(1, 2, 3))
@@ -86,7 +86,7 @@ val fromIter   = Chunk.fromIterator(Iterator.range(0, 10))
 
 ### From Java Collections
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 import java.util
 
@@ -101,7 +101,7 @@ val chunk = Chunk.fromJavaIterable(javaList)
 
 Chunk provides direct integration with Java NIO buffers:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 import java.nio.ByteBuffer
 
@@ -120,7 +120,7 @@ Available buffer constructors:
 
 ### Generator Functions
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val filled   = Chunk.fill(5)("x")         // Chunk("x", "x", "x", "x", "x")
@@ -132,7 +132,7 @@ val unfolded = Chunk.unfold(0)(n => if (n < 5) Some((n, n + 1)) else None)
 
 ### Element Access
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk = Chunk(10, 20, 30, 40, 50)
@@ -149,7 +149,7 @@ val maybeLast = chunk.lastOption // Some(50)
 
 For primitive chunks, specialized accessors avoid boxing:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val ints = Chunk(1, 2, 3)
@@ -164,7 +164,7 @@ val d: Double = doubles.double(0)  // unboxed access
 
 ### Transformations
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk = Chunk(1, 2, 3, 4, 5)
@@ -179,7 +179,7 @@ val collected = chunk.collect { case n if n % 2 == 0 => n * 10 } // Chunk(20, 40
 
 Concatenation is efficient—Chunk uses balanced tree structures to avoid copying:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val a = Chunk(1, 2, 3)
@@ -194,7 +194,7 @@ val prepended = 0 +: a          // Chunk(0, 1, 2, 3)
 
 Slicing operations create views and don't copy data:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk = Chunk(1, 2, 3, 4, 5, 6, 7, 8)
@@ -209,7 +209,7 @@ val (left, right) = chunk.splitAt(4)  // (Chunk(1,2,3,4), Chunk(5,6,7,8))
 
 ### Conditional Operations
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk = Chunk(1, 2, 3, 4, 5, 6)
@@ -222,7 +222,7 @@ val dropUntilBig   = chunk.dropUntil(_ > 3)    // Chunk(5, 6)
 
 ### Folding and Reduction
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk = Chunk(1, 2, 3, 4, 5)
@@ -236,7 +236,7 @@ val runningSum = chunk.foldWhile(0)(_ < 10)(_ + _) // 10 (1+2+3+4)
 
 ### Searching and Predicates
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk = Chunk(1, 2, 3, 4, 5)
@@ -249,7 +249,7 @@ val index    = chunk.indexWhere(_ > 3)   // 3
 
 ### Zipping
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val as = Chunk("a", "b", "c")
@@ -265,7 +265,7 @@ val zipAll      = as.zipAll(Chunk(1, 2))  // handles different lengths
 
 Updates are immutable and use efficient buffering:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk   = Chunk(1, 2, 3, 4, 5)
@@ -274,7 +274,7 @@ val updated = chunk.updated(2, 100) // Chunk(1, 2, 100, 4, 5)
 
 ### Deduplication and Sorting
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val withDupes = Chunk(1, 1, 2, 2, 2, 3, 3)
@@ -286,7 +286,7 @@ val sorted   = unsorted.sorted    // Chunk(1, 1, 3, 4, 5)
 
 ### Splitting
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk = Chunk(1, 2, 3, 4, 5, 6)
@@ -297,7 +297,7 @@ val (before, after) = chunk.splitWhere(_ > 3) // splits at first element > 3
 
 ### String Conversion
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 import java.nio.charset.StandardCharsets
 
@@ -315,7 +315,7 @@ val base64      = bytes.asBase64String // base64-encoded string
 
 For complex operation chains, you can force materialization to an array-backed chunk:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val complex = Chunk(1, 2, 3) ++ Chunk(4, 5) ++ Chunk(6, 7)
@@ -326,7 +326,7 @@ val materialized = complex.materialize // backed by a single array
 
 `NonEmptyChunk[A]` is a chunk guaranteed to contain at least one element. This enables safe use of operations like `head` and `reduce`:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.{Chunk, NonEmptyChunk}
 
 val nec = NonEmptyChunk(1, 2, 3)
@@ -340,7 +340,7 @@ val flatMapped: NonEmptyChunk[Int] = nec.flatMap(n => NonEmptyChunk(n, n + 1))
 
 ### Creating NonEmptyChunk
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.{Chunk, NonEmptyChunk}
 
 val fromValues = NonEmptyChunk(1, 2, 3)
@@ -354,7 +354,7 @@ val empty: Option[NonEmptyChunk[Int]] = NonEmptyChunk.fromChunk(Chunk.empty) //
 
 ### Converting Between Chunk and NonEmptyChunk
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.{Chunk, NonEmptyChunk}
 
 val nec = NonEmptyChunk(1, 2, 3)
@@ -382,7 +382,7 @@ Operations that might produce empty results return `Chunk`:
 
 `ChunkBuilder` is a mutable builder for creating chunks efficiently. It's specialized for primitives to avoid boxing:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.{Chunk, ChunkBuilder}
 
 val builder = ChunkBuilder.make[Int]()
@@ -396,7 +396,7 @@ val result: Chunk[Int] = builder.result() // Chunk(1, 2, 3, 4, 5)
 
 For primitives, use specialized builders for best performance:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.{Chunk, ChunkBuilder}
 
 val intBuilder = new ChunkBuilder.Int
@@ -418,7 +418,7 @@ Chunk provides efficient bit-level operations for working with binary data:
 
 ### Converting to Bits
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val bytes = Chunk[Byte](0x0F, 0xF0.toByte)
@@ -433,7 +433,7 @@ val longBits = longs.asBitsLong(Chunk.BitChunk.Endianness.BigEndian)
 
 ### Bitwise Operations
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val a = Chunk(true, false, true, false)
@@ -447,7 +447,7 @@ val negated   = a.negate // Chunk(false, true, false, true)
 
 ### Packing Booleans
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val bits = Chunk(true, false, true, false, true, true, true, true)
@@ -459,7 +459,7 @@ val packedLongs: Chunk[Long] = bits.toPackedLong(Chunk.BitChunk.Endianness.BigEn
 
 ### Binary String
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val bits = Chunk(true, false, true, true)
@@ -470,7 +470,7 @@ val binary: String = bits.toBinaryString // "1011"
 
 `ChunkMap[K, V]` is an order-preserving immutable map backed by parallel chunks. It maintains insertion order during iteration:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.{Chunk, ChunkMap}
 
 val map = ChunkMap("a" -> 1, "b" -> 2, "c" -> 3)
@@ -482,7 +482,7 @@ val removed = map.removed("b")
 
 ### Creating ChunkMap
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.{Chunk, ChunkMap}
 
 val empty = ChunkMap.empty[String, Int]
@@ -495,7 +495,7 @@ val fromChunks = ChunkMap.fromChunks(Chunk("a", "b"), Chunk(1, 2))
 
 ChunkMap provides O(1) positional access:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.{Chunk, ChunkMap}
 
 val map = ChunkMap("z" -> 1, "a" -> 2, "m" -> 3)
@@ -512,7 +512,7 @@ val values: Chunk[Int] = map.valuesChunk
 
 For frequent lookups, create an indexed version with O(1) key access:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.ChunkMap
 
 val map = ChunkMap("a" -> 1, "b" -> 2, "c" -> 3)
@@ -525,7 +525,7 @@ val value = indexed.get("b")  // O(1) instead of O(n)
 
 Chunk implements `IndexedSeq` and integrates seamlessly with Scala collections:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk = Chunk(1, 2, 3, 4, 5)
@@ -539,7 +539,7 @@ val fromSeq: Chunk[Int] = Chunk.from(Vector(1, 2, 3))
 
 Standard collection operations work as expected:
 
-```scala mdoc:compile-only
+```scala
 import zio.blocks.chunk.Chunk
 
 val chunk = Chunk(1, 2, 3)

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" % "@VERSION@"
+libraryDependencies += "dev.zio" %% "zio-blocks-docs" % "0.0.21"
 ```
 
 ## Core Types
@@ -170,7 +170,7 @@ The parser supports all GitHub Flavored Markdown features:
 - **Tables with alignment**
 - **Inline formatting** (emphasis, strong, strikethrough, code)
 - **Links and images**
-- **Autolinks** (<url> or plain URLs)
+- **Autolinks** (`<url>` or plain URLs)
 - **HTML blocks and inline HTML**
 
 ### Not Supported