add Cause.Annotated

.changeset/calm-houses-brake.md

@@ -0,0 +1,20 @@
+---
+"effect": minor
+---
+
+add `Logger.withLeveledConsole`
+
+In browsers and different platforms, `console.error` renders differently than `console.info`. This helps to distinguish between different levels of logging. `Logger.withLeveledConsole` takes any logger and calls the respective `Console` method based on the log level. For instance, `Effect.logError` will call `Console.error` and `Effect.logInfo` will call `Console.info`.
+
+To use it, you can replace the default logger with a `Logger.withLeveledConsole` logger:
+
+```ts
+import { Logger, Effect } from "effect"
+
+const loggerLayer = Logger.withLeveledConsole(Logger.stringLogger)
+
+Effect.gen(function* () {
+  yield* Effect.logError("an error")
+  yield* Effect.logInfo("an info")
+}).pipe(Effect.provide(loggerLayer))
+```

.changeset/eighty-lobsters-refuse.md

@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+Made `Ref`, `SynchronizedRed` and `SubscriptionRef` a subtype of `Effect`

.changeset/few-mayflies-speak.md

@@ -0,0 +1,21 @@
+---
+"effect": minor
+---
+
+add Semaphore.withPermitsIfAvailable
+
+You can now use `Semaphore.withPermitsIfAvailable` to run an Effect only if the
+Semaphore has enough permits available. This is useful when you want to run an
+Effect only if you can acquire a permit without blocking.
+
+It will return an `Option.Some` with the result of the Effect if the permits were
+available, or `None` if they were not.
+
+```ts
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+  const semaphore = yield* Effect.makeSemaphore(1)
+  semaphore.withPermitsIfAvailable(1)(Effect.void)
+})
+```

.changeset/gorgeous-toes-help.md

@@ -0,0 +1,16 @@
+---
+"effect": minor
+---
+
+The `Deferred<A>` is now a subtype of `Effect<A>`. This change simplifies handling of deferred values, removing the need for explicit call `Deffer.await`.
+
+```typescript
+import { Effect, Deferred } from "effect"
+
+Effect.gen(function* () {
+  const deferred = yield* Deferred.make<string>()
+
+  const before = yield* Deferred.await(deferred)
+  const after = yield* deferred
+})
+```

.changeset/honest-cups-wash.md

@@ -0,0 +1,6 @@
+---
+"effect": minor
+"@effect/platform": patch
+---
+
+add Logger.prettyLoggerDefault, to prevent duplicate pretty loggers

.changeset/lucky-eagles-speak.md

@@ -0,0 +1,24 @@
+---
+"effect": minor
+---
+
+add Effect.makeLatch, for creating a simple async latch
+
+```ts
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+  // Create a latch, starting in the closed state
+  const latch = yield* Effect.makeLatch(false)
+
+  // Fork a fiber that logs "open sesame" when the latch is opened
+  const fiber = yield* Effect.log("open sesame").pipe(
+    latch.whenOpen,
+    Effect.fork
+  )
+
+  // Open the latch
+  yield* latch.open
+  yield* fiber.await
+})
+```

.changeset/quick-roses-warn.md

@@ -0,0 +1,6 @@
+---
+"effect": minor
+"@effect/cli": patch
+---
+
+Add Number.round

.changeset/seven-lamps-nail.md

@@ -0,0 +1,16 @@
+---
+"effect": minor
+---
+
+The `Fiber<A, E>` is now a subtype of `Effect<A, E>`. This change removes the need for explicit call `Fiber.join`.
+
+```typescript
+import { Effect, Fiber } from "effect"
+
+Effect.gen(function*() {
+  const fiber = yield* Effect.fork(Effect.succeed(1))
+
+  const oldWay = yield* Fiber.join(fiber)
+  const now = yield* fiber
+}))
+```

.changeset/stream-share.md

@@ -0,0 +1,10 @@
+---
+"effect": minor
+---
+
+add `Stream.share` api
+
+The `Stream.share` api is a ref counted variant of the broadcast apis.
+
+It allows you to share a stream between multiple consumers, and will close the
+upstream when the last consumer ends.

.changeset/strong-moose-tickle.md

@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+add Cause.Annotated

.changeset/tender-foxes-walk.md

@@ -0,0 +1,87 @@
+---
+"@effect/platform-browser": minor
+"@effect/platform-node": minor
+"@effect/platform-bun": minor
+"@effect/platform": minor
+"@effect/rpc-http": minor
+---
+
+refactor /platform HttpClient
+
+#### HttpClient.fetch removed
+
+The `HttpClient.fetch` client implementation has been removed. Instead, you can
+access a `HttpClient` using the corresponding `Context.Tag`.
+
+```ts
+import { FetchHttpClient, HttpClient } from "@effect/platform"
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+  const client = yield* HttpClient.HttpClient
+
+  // make a get request
+  yield* client.get("https://jsonplaceholder.typicode.com/todos/1")
+}).pipe(
+  Effect.scoped,
+  // the fetch client has been moved to the `FetchHttpClient` module
+  Effect.provide(FetchHttpClient.layer)
+)
+```
+
+#### `HttpClient` interface now uses methods
+
+Instead of being a function that returns the response, the `HttpClient`
+interface now uses methods to make requests.
+
+Some shorthand methods have been added to the `HttpClient` interface to make
+less complex requests easier.
+
+```ts
+import {
+  FetchHttpClient,
+  HttpClient,
+  HttpClientRequest
+} from "@effect/platform"
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+  const client = yield* HttpClient.HttpClient
+
+  // make a get request
+  yield* client.get("https://jsonplaceholder.typicode.com/todos/1")
+  // make a post request
+  yield* client.post("https://jsonplaceholder.typicode.com/todos")
+
+  // execute a request instance
+  yield* client.execute(
+    HttpClientRequest.get("https://jsonplaceholder.typicode.com/todos/1")
+  )
+})
+```
+
+#### Scoped `HttpClientResponse` helpers removed
+
+The `HttpClientResponse` helpers that also eliminated the `Scope` have been removed.
+
+Instead, you can use the `HttpClientResponse` methods directly, and explicitly
+add a `Effect.scoped` to the pipeline.
+
+```ts
+import { FetchHttpClient, HttpClient } from "@effect/platform"
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+  const client = yield* HttpClient.HttpClient
+
+  yield* client.get("https://jsonplaceholder.typicode.com/todos/1").pipe(
+    Effect.flatMap((response) => response.json),
+    Effect.scoped // eliminate the `Scope`
+  )
+})
+```
+
+#### Some apis have been renamed
+
+Including the `HttpClientRequest` body apis, which is to make them more
+discoverable.

.changeset/thick-coats-buy.md

@@ -0,0 +1,5 @@
+---
+"@effect/platform": patch
+---
+
+Added refinement overloads to `HttpClient.filterOrFail` and `HttpClient.filterOrElse`

.changeset/twelve-dingos-destroy.md

@@ -0,0 +1,6 @@
+---
+"@effect/opentelemetry": minor
+"effect": minor
+---
+
+Cache some fiber references in the runtime to optimize reading in hot-paths

.changeset/violet-suns-chew.md

@@ -0,0 +1,26 @@
+---
+"effect": minor
+---
+
+Added `RcMap.keys` and `MutableHashMap.keys`.
+
+These functions allow you to get a list of keys currently stored in the underlying hash map.
+
+```ts
+const map = MutableHashMap.make([["a", "a"], ["b", "b"], ["c", "c"]])
+const keys = MutableHashMap.keys(map) // ["a", "b", "c"]
+```
+
+```ts
+Effect.gen(function* () {
+  const map = yield* RcMap.make({
+    lookup: (key) => Effect.succeed(key)
+  })
+
+  yield* RcMap.get(map, "a")
+  yield* RcMap.get(map, "b")
+  yield* RcMap.get(map, "c")
+
+  const keys = yield* RcMap.keys(map) // ["a", "b", "c"]
+})
+```

.changeset/wise-kiwis-tan.md

@@ -0,0 +1,16 @@
+---
+"effect": minor
+---
+
+The `FiberRef<A>` is now a subtype of `Effect<A>`. This change simplifies handling of deferred values, removing the need for explicit call `FiberRef.get`.
+
+```typescript
+import { Effect, FiberRef } from "effect"
+
+Effect.gen(function* () {
+  const fiberRef = yield* FiberRef.make("value")
+
+  const before = yield* FiberRef.get(fiberRef)
+  const after = yield* fiberRef
+})
+```

packages/cli/src/internal/prompt/number.ts

@@ -5,6 +5,7 @@ import * as Optimize from "@effect/printer/Optimize"
 import * as Schema from "@effect/schema/Schema"
 import * as Arr from "effect/Array"
 import * as Effect from "effect/Effect"
+import * as EffectNumber from "effect/Number"
 import * as Option from "effect/Option"
 import type * as Prompt from "../../Prompt.js"
 import * as InternalPrompt from "../prompt.js"
@@ -20,11 +21,6 @@ interface State {
   readonly error: Option.Option<string>
 }
 
-const round = (number: number, precision: number) => {
-  const factor = Math.pow(10, precision)
-  return Math.round(number * factor) / factor
-}
-
 const parseInt = Schema.NumberFromString.pipe(
   Schema.int(),
   Schema.decodeUnknown
@@ -352,7 +348,7 @@ function handleProcessFloat(options: FloatOptions) {
             })),
           onSuccess: (n) =>
             Effect.flatMap(
-              Effect.sync(() => round(n, options.precision)),
+              Effect.sync(() => EffectNumber.round(n, options.precision)),
               (rounded) =>
                 Effect.match(options.validate(rounded), {
                   onFailure: (error) =>

packages/cluster-node/examples/sample-connect.ts

@@ -30,25 +30,33 @@ const liveLayer = Effect.gen(function*() {
   Layer.effectDiscard,
   Layer.provide(Sharding.live),
   Layer.provide(StorageFile.storageFile),
-  Layer.provide(PodsRpc.podsRpc<never>((podAddress) =>
-    HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
-      HttpClient.fetchOk.pipe(
-        HttpClient.mapRequest(
-          HttpClientRequest.prependUrl(`http://${podAddress.host}:${podAddress.port}/api/rest`)
-        )
-      )
-    ).pipe(RpcResolver.toClient)
-  )),
-  Layer.provide(ShardManagerClientRpc.shardManagerClientRpc(
-    (shardManagerUri) =>
+  Layer.provide(Layer.unwrapEffect(Effect.gen(function*() {
+    const client = yield* HttpClient.HttpClient
+    return PodsRpc.podsRpc<never>((podAddress) =>
       HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
-        HttpClient.fetchOk.pipe(
+        client.pipe(
+          HttpClient.filterStatusOk,
           HttpClient.mapRequest(
-            HttpClientRequest.prependUrl(shardManagerUri)
+            HttpClientRequest.prependUrl(`http://${podAddress.host}:${podAddress.port}/api/rest`)
           )
         )
       ).pipe(RpcResolver.toClient)
-  )),
+    )
+  }))),
+  Layer.provide(Layer.unwrapEffect(Effect.gen(function*() {
+    const client = yield* HttpClient.HttpClient
+    return ShardManagerClientRpc.shardManagerClientRpc(
+      (shardManagerUri) =>
+        HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
+          client.pipe(
+            HttpClient.filterStatusOk,
+            HttpClient.mapRequest(
+              HttpClientRequest.prependUrl(shardManagerUri)
+            )
+          )
+        ).pipe(RpcResolver.toClient)
+    )
+  }))),
   Layer.provide(ShardingConfig.withDefaults({ shardingPort: 54322 })),
   Layer.provide(Serialization.json),
   Layer.provide(NodeHttpClient.layerUndici)