effect 4.0.5 → 4.0.6

package/src/HashSet.ts

@@ -939,71 +939,11 @@ export const filter: {
   <V>(self: HashSet<V>, predicate: Predicate<V>): HashSet<V>
 } = Dual.dual<
   {
-    /**
-     * Filters the HashSet keeping only values that satisfy the predicate.
-     *
-     * **Example** (Filtering HashSet values)
-     *
-     * ```ts import.meta.vitest
-     * import { HashSet } from "effect"
-     *
-     * HashSet.filter(HashSet.make(1, 2, 3, 4, 5, 6), (n) => n % 2 === 0) // => HashSet.make(2, 4, 6)
-     * ```
-     *
-     * @stability stable
-     * @category filtering
-     * @since 2.0.0
-     */
     <V, U extends V>(refinement: Refinement<NoInfer<V>, U>): (self: HashSet<V>) => HashSet<U>
-    /**
-     * Filters the HashSet keeping only values that satisfy the predicate.
-     *
-     * **Example** (Filtering HashSet values)
-     *
-     * ```ts import.meta.vitest
-     * import { HashSet } from "effect"
-     *
-     * HashSet.filter(HashSet.make(1, 2, 3, 4, 5, 6), (n) => n % 2 === 0) // => HashSet.make(2, 4, 6)
-     * ```
-     *
-     * @stability stable
-     * @category filtering
-     * @since 2.0.0
-     */
     <V>(predicate: Predicate<NoInfer<V>>): (self: HashSet<V>) => HashSet<V>
   },
   {
-    /**
-     * Filters the HashSet keeping only values that satisfy the predicate.
-     *
-     * **Example** (Filtering HashSet values)
-     *
-     * ```ts import.meta.vitest
-     * import { HashSet } from "effect"
-     *
-     * HashSet.filter(HashSet.make(1, 2, 3, 4, 5, 6), (n) => n % 2 === 0) // => HashSet.make(2, 4, 6)
-     * ```
-     *
-     * @stability stable
-     * @category filtering
-     * @since 2.0.0
-     */
     <V, U extends V>(self: HashSet<V>, refinement: Refinement<V, U>): HashSet<U>
-    /**
-     * Filters the HashSet keeping only values that satisfy the predicate.
-     *
-     * **Example** (Filtering HashSet values)
-     *
-     * ```ts import.meta.vitest
-     * import { HashSet } from "effect"
-     *
-     * HashSet.filter(HashSet.make(1, 2, 3, 4, 5, 6), (n) => n % 2 === 0) // => HashSet.make(2, 4, 6)
-     * ```
-     *
-     * @stability stable
-     * @category filtering
-     * @since 2.0.0
-     */
     <V>(self: HashSet<V>, predicate: Predicate<V>): HashSet<V>
   }
 >(2, internal.filter)

package/src/Iterable.ts

@@ -4889,21 +4889,22 @@ export const dedupeAdjacentWith: {
     let first = true
     let last: A
     function next(): IteratorResult<A> {
-      const result = iterator.next()
-      if (result.done) {
-        return { done: true, value: undefined }
-      }
-      if (first) {
-        first = false
-        last = result.value
-        return result
-      }
-      const current = result.value
-      if (isEquivalent(last, current)) {
-        return next()
+      while (true) {
+        const result = iterator.next()
+        if (result.done) {
+          return { done: true, value: undefined }
+        }
+        if (first) {
+          first = false
+          last = result.value
+          return result
+        }
+        const current = result.value
+        if (!isEquivalent(last, current)) {
+          last = current
+          return result
+        }
       }
-      last = current
-      return result
     }
     return { next }
   }

package/src/JsonSchema.ts

@@ -416,9 +416,15 @@ export function fromSchemaOpenApi3_1(js: JsonSchema): Document<"draft-2020-12">
  *
  * **Gotchas**
  *
- * OpenAPI 3.0 `nullable` is applied only when the same Schema Object has an
- * explicit string `type`; other constraints such as `enum` are left
- * unchanged. Unknown keywords, vendor extensions, and annotation values are
+ * OpenAPI 3.0 specifies that `nullable` applies only when the same Schema
+ * Object has an explicit string `type`. For compatibility with tooling that
+ * uses a single-member `allOf` for nullable references, this converter also
+ * rewrites `{ nullable: true, allOf: [schema] }` to
+ * `{ anyOf: [schema, { type: "null" }] }` when there is no string `type` or
+ * existing `anyOf`. Sibling constraints such as `enum` remain unchanged and
+ * may still reject null.
+ *
+ * Unknown keywords, vendor extensions, and annotation values are
  * copied opaquely unless their name would become active in Draft 2020-12 and
  * change meaning, in which case conversion throws. Siblings of a valid
  * OpenAPI 3.0 `$ref` are ignored.
@@ -1331,8 +1337,17 @@ function convertOpenApi30(root: JsonSchema): JsonSchema {
     }
     rejectKeywordCollisions(source, OPEN_API_30_TO_2020_COLLISIONS, "Draft 2020-12", "OpenAPI 3.0")
 
+    const nullableAllOf = isOpenApi30NullableAllOf(source)
+
     for (const key of Object.keys(source)) {
       const value = source[key]
+      if (nullableAllOf && key === "allOf") {
+        InternalRecord.assignProperty(out, "anyOf", [
+          context.schemaAt(source.allOf[0], ["allOf", "0"], ["anyOf", "0"]),
+          { type: "null" }
+        ])
+        continue
+      }
       if (
         convertSubschemaKeyword(
           out,
@@ -1369,6 +1384,16 @@ function convertOpenApi30(root: JsonSchema): JsonSchema {
   })
 }
 
+function isOpenApi30NullableAllOf(
+  source: JsonSchema
+): source is JsonSchema & { readonly allOf: readonly [unknown] } {
+  return source.nullable === true &&
+    typeof source.type !== "string" &&
+    source.anyOf === undefined &&
+    Array.isArray(source.allOf) &&
+    source.allOf.length === 1
+}
+
 function convertOpenApiExclusiveBound(
   source: JsonSchema,
   out: JsonSchema,

package/src/Layer.ts

@@ -1694,7 +1694,7 @@ export const mergeAll = <Layers extends [Layer<never, any, any>, ...Array<Layer<
   Success<Layers[number]>,
   Error<Layers[number]>,
   Services<Layers[number]>
-> => fromBuild((memoMap, scope) => mergeAllEffect(layers, memoMap, scope))
+> => fromBuildMemo((memoMap, scope) => mergeAllEffect(layers, memoMap, scope))
 
 /**
  * Merges this layer with another layer concurrently, producing a new layer with
@@ -1956,7 +1956,7 @@ const provideWith = (
     thatContext: Context.Context<any>
   ) => Context.Context<any>
 ) =>
-  fromBuild((memoMap, scope) =>
+  fromBuildMemo((memoMap, scope) =>
     internalEffect.flatMap(
       Array.isArray(that)
         ? mergeAllEffect(that as NonEmptyArray<Layer<any, any, any>>, memoMap, scope)

package/src/ManagedRuntime.ts

@@ -1,3 +1,5 @@
+/// <reference lib="esnext.disposable" preserve="true" />
+
 /**
  * Runs many effects against services built once from a `Layer`.
  *
@@ -10,11 +12,12 @@
  * @stability stable
  * @since 2.0.0
  */
-import type * as Context from "./Context.ts"
+import * as Context from "./Context.ts"
+import * as Deferred from "./Deferred.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
-import { type FiberImpl, scopeRemoveFinalizerUnsafe } from "./internal/effect.ts"
+import { fiberEnterUninterruptibleUnsafe, type FiberImpl, scopeRemoveFinalizerUnsafe } from "./internal/effect.ts"
 import * as Layer from "./Layer.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Scope from "./Scope.ts"
@@ -209,6 +212,10 @@ export interface ManagedRuntime<in R, out ER> {
    * **When to use**
    *
    * Use to release this runtime's layer resources from Promise-based code.
+   *
+   * **Details**
+   *
+   * Calls made while a disposal is in progress wait for it to finish.
    */
   readonly dispose: () => Promise<void>
 
@@ -228,10 +235,32 @@ export interface ManagedRuntime<in R, out ER> {
    * **When to use**
    *
    * Use to release this runtime's layer resources from an `Effect` workflow.
+   *
+   * **Details**
+   *
+   * Disposal runs uninterruptibly. Calls made while a disposal is in progress
+   * wait for it to finish, and interrupting a waiting call only stops the wait.
+   * Fibers started by this runtime, their child fibers, and the runtime's
+   * finalizers do not wait: the disposal interrupts or runs them, so waiting
+   * would deadlock.
    */
   readonly disposeEffect: Effect.Effect<void, never, never>
 }
 
+// The runtimes whose disposal the current fiber is running. A disposal adds its
+// runtime to the set it inherits, so a finalizer that disposes another runtime
+// still belongs to the outer disposals. Finalizers and their parallel fibers
+// inherit the set from the disposing fiber. It is not provided to the layer
+// build, because finalizers of layers shared through a MemoMap run with the
+// build context of the runtime that built them, which may not be the runtime
+// disposing them.
+const DisposingRuntimes = Context.Reference<ReadonlySet<ManagedRuntime<any, any>>>(
+  "effect/ManagedRuntime/DisposingRuntimes",
+  {
+    defaultValue: () => new Set()
+  }
+)
+
 /**
  * Creates a `ManagedRuntime` from a layer.
  *
@@ -252,6 +281,11 @@ export interface ManagedRuntime<in R, out ER> {
  * Dispose the runtime when it is no longer needed. A runtime cannot be reused
  * after disposal.
  *
+ * A failed layer build is also cached: subsequent runs return the same build
+ * failure without rebuilding the layer. For transient failures, retry inside
+ * the layer before passing it to `make`, or dispose the runtime and create a
+ * new one to attempt a fresh build.
+ *
  * **Example** (Creating a managed runtime)
  *
  * ```ts import.meta.vitest
@@ -298,8 +332,17 @@ export const make = <R, ER>(
   const scope = Scope.makeUnsafe("sequential")
   const layerScope = Scope.forkUnsafe(scope, "sequential")
   const fiberScope = Scope.forkUnsafe(scope, "parallel")
+  // Fibers started by the runtime, including the layer build, are interrupted
+  // and awaited by its disposal, so they and their child fibers must not wait
+  // for it.
+  const managedFibers = new WeakSet<Fiber.Fiber<any, any>>()
+  const disposingFibers = new WeakSet<Fiber.Fiber<any, any>>()
   const defaultRunOptions: Effect.RunOptions = {
-    onFiberStart: Fiber.runIn(fiberScope)
+    onFiberStart(fiber) {
+      managedFibers.add(fiber)
+      if (disposingFibers.has(fiber)) return
+      Fiber.runIn(fiber, fiberScope)
+    }
   }
   const mergeRunOptions = <O extends Effect.RunOptions>(options?: O): O =>
     options
@@ -314,6 +357,7 @@ export const make = <R, ER>(
       }
       : defaultRunOptions as O
   let buildFiber: Fiber.Fiber<Context.Context<R>, ER> | undefined
+  let disposed: Deferred.Deferred<void> | undefined
   const contextEffect = Effect.withFiber<Context.Context<R>, ER>((fiber) => {
     if (!buildFiber) {
       buildFiber = Effect.runFork(
@@ -324,7 +368,15 @@ export const make = <R, ER>(
               self.cachedContext = context
             })
         ),
-        { ...defaultRunOptions, scheduler: fiber.cache.scheduler }
+        {
+          scheduler: fiber.cache.scheduler,
+          // Unlike requests, the build joins fiberScope even if it disposed the
+          // runtime, so disposal still interrupts it.
+          onFiberStart(fiber) {
+            managedFibers.add(fiber)
+            Fiber.runIn(fiber, fiberScope)
+          }
+        }
       )
     }
     return Effect.flatten(Fiber.await(buildFiber))
@@ -347,14 +399,28 @@ export const make = <R, ER>(
       return self.dispose()
     },
     disposeEffect: Effect.withFiber((fiber) => {
-      // Closing fiberScope interrupts and awaits every managed fiber. Skip the
+      if (disposed !== undefined) {
+        if (fiber.getRef(DisposingRuntimes).has(self)) return Effect.void
+        for (let current = fiber as FiberImpl<any, any> | undefined; current; current = current._parent) {
+          if (managedFibers.has(current)) return Effect.void
+        }
+        return Deferred.await(disposed)
+      }
+      // Once `disposed` is set the close must run, or later calls would wait forever.
+      fiberEnterUninterruptibleUnsafe(fiber)
+      const done = disposed = Deferred.makeUnsafe<void>()
+      // Closing fiberScope interrupts and awaits every managed fiber. Exempt the
       // disposing fiber and its ancestors, which would otherwise await themselves.
       for (let current = fiber as FiberImpl<any, any> | undefined; current; current = current._parent) {
+        disposingFibers.add(current)
         scopeRemoveFinalizerUnsafe(fiberScope, current)
       }
       ;(self as Mutable<ManagedRuntime<R, ER>>).contextEffect = Effect.die("ManagedRuntime disposed")
       self.cachedContext = undefined
-      return Scope.close(self.scope, Exit.void)
+      return Scope.close(self.scope, Exit.void).pipe(
+        Effect.provideService(DisposingRuntimes, new Set(fiber.getRef(DisposingRuntimes)).add(self)),
+        Effect.ensuring(Deferred.done(done, Exit.void))
+      )
     }),
     runFork<A, E>(effect: Effect.Effect<A, E, R>, options?: Effect.RunOptions): Fiber.Fiber<A, E | ER> {
       return self.cachedContext === undefined ?