@zio.dev/zio-blocks 0.0.33 → 0.0.51

package/reference/resource-management/defer-handle.md

@@ -229,7 +229,7 @@ val result = Scope.global.scoped { scope =>
 
 ## See Also
 
-- [`Scope#defer`](./scope.md#registering-finalizers) — the method that returns a `DeferHandle`
+- [`Scope#defer`](./scope.md#finalizer) — the method that returns a `DeferHandle`
 - [`Finalizer`](./finalizer.md) — the trait defining `Finalizer#defer`
 - [`Finalization`](./finalization.md) — the result of running all finalizers
 

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.33"
+libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.51"
 ```
 
 For cross-platform (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-scope" % "0.0.33"
+libraryDependencies += "dev.zio" %%% "zio-blocks-scope" % "0.0.51"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.
@@ -608,6 +608,35 @@ implicit class ResourceOps[A](private val r: Resource[A]) {
 }
 ```
 
+### `Resource#use` — Acquire, Use, and Finalize
+
+For top-level application code, `use` provides a lighter API than spelling out
+`Scope.global.scoped` and `allocate` directly:
+
+```scala
+trait Resource[+A] {
+  def use[B](f: A => B)(implicit ev: Unscoped[B]): B
+}
+```
+
+Example:
+
+```scala
+import zio.blocks.scope._
+
+class HttpServer extends AutoCloseable {
+  def start(): Unit = println("server started")
+  def close(): Unit = println("server stopped")
+}
+
+val serverResource = Resource.fromAutoCloseable(new HttpServer)
+
+serverResource.use(_.start())
+```
+
+`use` still creates a global scope under the hood, acquires the resource,
+runs the callback, and guarantees finalization when the callback returns.
+
 To allocate a resource and use its value inside a scope:
 
 ```scala

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.33"
+libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.51"
 ```
 
 Supported Scala versions: **2.13.x** and **3.x**.
@@ -811,24 +811,40 @@ final class App(service: UserService) {
 
 // Wire describes the dependency graph: App -> UserService -> Database -> Config
 // Resource.from uses the Wire to automatically construct the entire graph
-Scope.global.scoped { scope =>
-  import scope._
-  val config = Config("jdbc:postgres://localhost/db")
-  val app = allocate(Resource.from[App](
-    Wire(config)
-  ))
-  $(app)(_.run())
-  // All resources (Database, App) clean up automatically in reverse order
-}
+val config = Config("jdbc:postgres://localhost/db")
+val appResource = Resource.from[App](
+  Wire(config)
+)
+
+appResource.use(_.run())
+// All resources (Database, App) clean up automatically in reverse order
 ```
 
 For more details on `Wire` sharing strategies, resource composition, and advanced DI patterns, see the [Wire reference](./wire.md) and [Resource reference](./resource.md).
 
 ## Best Practices
 
-### Entry point pattern — use `Scope.global.scoped` at the top level
+### Entry point pattern — use `Resource#use` for app startup, `Scope.global.scoped` for manual scope control
+
+For application entrypoints, prefer the lighter `Resource#use` API when you
+have a root resource:
+
+```scala
+import zio.blocks.scope._
+
+class App {
+  def run(): Unit = println("running")
+}
+
+val appResource: Resource[App] = Resource(new App)
+
+appResource.use(_.run())
+```
+
+Reach for `Scope.global.scoped` directly when you need manual control over
+multiple allocations, child scopes, lowering, or explicit `$` access.
 
-Wrap your entire application's resource acquisition in a single lexical scope:
+That lower-level form still looks like this:
 
 ```scala
 import zio.blocks.scope._

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.33"
+libraryDependencies += "dev.zio" %% "zio-blocks-scope" % "0.0.51"
 ```
 
 For cross-platform (Scala.js):
 
 ```scala
-libraryDependencies += "dev.zio" %%% "zio-blocks-scope" % "0.0.33"
+libraryDependencies += "dev.zio" %%% "zio-blocks-scope" % "0.0.51"
 ```
 
 Supported Scala versions: 2.13.x and 3.x.
@@ -496,11 +496,7 @@ val appResource: Resource[App] = Resource.from[App](
   Wire(AppConfig("jdbc:postgres://localhost/db"))
 )
 
-Scope.global.scoped { scope =>
-  import scope._
-  val app = allocate(appResource)
-  $(app)(_.run())
-}
+appResource.use(_.run())
 ```
 
 When `Resource.from` composes wires, it respects the sharing strategy: