effect 4.0.4 → 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 ?

package/src/Match.ts

@@ -712,6 +712,26 @@ export const withReturnType: <Ret>() => <I, F, R, A, Pr, _, Args extends Array<a
 ) => [Ret] extends [[A] extends [never] ? any : A] ? Matcher<I, F, R, A, Pr, Ret, Args>
   : "withReturnType constraint does not extend Result type" = internal.withReturnType
 
+// `P` is a const type parameter, so object literals skip excess-property checks.
+// Reject pattern keys that no object variant of the input has. Functions,
+// refinements, and array patterns are not checked.
+type PatternKey<K> = K extends number ? `${K}` : K
+
+type PatternKeys<A> = object extends A ? PropertyKey
+  : A extends object ? PatternKey<keyof A>
+  : never
+
+type ObjectPatternGuard<A, P> = [P] extends [Function | ReadonlyArray<any> | SafeRefinement<never, any>] ? unknown
+  : [P] extends [object] ? { readonly [K in Exclude<PatternKey<keyof P>, PatternKeys<A>>]: never }
+  : unknown
+
+type ExactPattern<R, P> = (Types.PatternPrimitive<R> | Types.PatternBase<R>) & ObjectPatternGuard<R, P>
+
+type ExactPatterns<R, P> = {
+  readonly [I in keyof P]: I extends number | `${number}` ? P[I] & ExactPattern<R, P[I]>
+    : P[I]
+}
+
 /**
  * Defines a condition for matching values.
  *
@@ -763,7 +783,7 @@ export const withReturnType: <Ret>() => <I, F, R, A, Pr, _, Args extends Array<a
  */
 export const when: <
   R,
-  const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
+  const P extends ExactPattern<R, P>,
   Ret,
   Args extends Array<any>,
   Fn extends (_: Types.WhenMatch<R, P>, ...args: Args) => Ret
@@ -831,7 +851,7 @@ export const whenOr: <
   Args extends Array<any>,
   Fn extends (_: Types.WhenMatch<R, P[number]>, ...args: Args) => Ret
 >(
-  ...args: [...patterns: P, f: Fn]
+  ...args: [...patterns: ExactPatterns<R, P>, f: Fn]
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret, Args>
 ) => Matcher<
@@ -842,7 +862,13 @@ export const whenOr: <
   Pr,
   Ret,
   Args
-> = internal.whenOr
+> = <
+  R,
+  const P extends ReadonlyArray<Types.PatternPrimitive<R> | Types.PatternBase<R>>,
+  Ret,
+  Args extends Array<any>,
+  Fn extends (_: Types.WhenMatch<R, P[number]>, ...args: Args) => Ret
+>(...args: [...patterns: ExactPatterns<R, P>, f: Fn]) => internal.whenOr<R, P, Ret, Args, Fn>(...args)
 
 /**
  * Matches a value that satisfies all provided patterns.
@@ -890,7 +916,7 @@ export const whenAnd: <
   Args extends Array<any>,
   Fn extends (_: Types.WhenMatch<R, T.UnionToIntersection<P[number]>>, ...args: Args) => Ret
 >(
-  ...args: [...patterns: P, f: Fn]
+  ...args: [...patterns: ExactPatterns<R, P>, f: Fn]
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret, Args>
 ) => Matcher<
@@ -901,7 +927,13 @@ export const whenAnd: <
   Pr,
   Ret,
   Args
-> = internal.whenAnd
+> = <
+  R,
+  const P extends ReadonlyArray<Types.PatternPrimitive<R> | Types.PatternBase<R>>,
+  Ret,
+  Args extends Array<any>,
+  Fn extends (_: Types.WhenMatch<R, T.UnionToIntersection<P[number]>>, ...args: Args) => Ret
+>(...args: [...patterns: ExactPatterns<R, P>, f: Fn]) => internal.whenAnd<R, P, Ret, Args, Fn>(...args)
 
 /**
  * Matches values based on a specified discriminant field.
@@ -1398,7 +1430,7 @@ export const tagsExhaustive: <
  */
 export const not: <
   R,
-  const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
+  const P extends ExactPattern<R, P>,
   Ret,
   Args extends Array<any>,
   Fn extends (_: Types.NotMatch<R, P>, ...args: Args) => Ret
@@ -2835,6 +2867,32 @@ export declare namespace Types {
 
   type Simplify<A> = { [K in keyof A]: A[K] } & {}
 
+  // Tuple patterns match a prefix at runtime. For inputs with a variadic part,
+  // narrow each position the pattern requires and keep the rest of the input.
+  type NarrowArrayPattern<I extends ReadonlyArray<any>, P extends ReadonlyArray<any>> = number extends I["length"]
+    ? number extends P["length"] ? MapArrayPattern<I, P>
+    : P["length"] extends Required<P>["length"] ? NarrowArrayPrefix<I, P>
+    : MapArrayPattern<I, P>
+    : MapArrayPattern<I, P>
+
+  type MapArrayPattern<I, P> = {
+    readonly [K in keyof I]: K extends keyof P ? ExtractAndNarrow<I[K], P[K]> : I[K]
+  } extends infer R ? Fail extends R[keyof R] ? never
+    : R
+    : never
+
+  type NarrowArrayPrefix<
+    I extends ReadonlyArray<any>,
+    P extends ReadonlyArray<any>,
+    Out extends ReadonlyArray<any> = readonly []
+  > = P extends readonly [infer PH, ...infer PT] ?
+    I extends readonly [infer IH, ...infer IT] ?
+      [ExtractAndNarrow<IH, PH>] extends [infer N] ? [N] extends [never] ? never
+        : NarrowArrayPrefix<IT, PT, readonly [...Out, N]>
+      : never
+    : NarrowArrayPrefix<readonly [I[number], ...Array<I[number]>], P, Out>
+    : readonly [...Out, ...I]
+
   type ExtractAndNarrow<Input, P> = P extends Predicate.Refinement<infer _In, infer _Out> ?
     _Out extends Input ? Extract<_Out, Input>
     : Extract<Input, _Out> :
@@ -2843,12 +2901,7 @@ export declare namespace Types {
       : Extract<Input, _In>
     : P extends Predicate.Predicate<infer _In> ? Extract<Input, _In>
     : Input extends infer I ? Exclude<
-        I extends ReadonlyArray<any> ? P extends ReadonlyArray<any> ? {
-              readonly [K in keyof I]: K extends keyof P ? ExtractAndNarrow<I[K], P[K]>
-                : I[K]
-            } extends infer R ? Fail extends R[keyof R] ? never
-              : R
-            : never
+        I extends ReadonlyArray<any> ? P extends ReadonlyArray<any> ? NarrowArrayPattern<I, P>
           : never
           : IsPlainObject<I> extends true ? string extends keyof I ? I extends P ? I
               : never