effect 4.0.5 → 4.0.7

package/src/Hash.ts

@@ -11,7 +11,7 @@
  * @since 2.0.0
  */
 import { dual } from "./Function.ts"
-import { byReferenceInstances, getAllObjectKeys, viewBytes } from "./internal/equal.ts"
+import { bufferBytes, byReferenceInstances, getAllObjectKeys, isArrayBufferLike, viewBytes } from "./internal/equal.ts"
 import { addBackEdge, backEdges } from "./internal/hash.ts"
 import { hasProperty } from "./Predicate.ts"
 
@@ -144,6 +144,9 @@ export const hash: <A>(self: A) => number = <A>(self: A) => {
             h = (self as Hash)[symbol]()
           } else if (typeof self === "function") {
             h = random(self)
+          } else if (isArrayBufferLike(self)) {
+            const bytes = bufferBytes(self)
+            h = bytes === undefined ? random(self) : array(bytes)
           } else if (self instanceof DataView) {
             h = array(viewBytes(self))
           } else if (Array.isArray(self) || ArrayBuffer.isView(self)) {

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/JsonPatch.ts

@@ -303,12 +303,16 @@ function isJsonObject(value: unknown): value is Schema.JsonObject {
  *
  * - `""` (empty pointer) refers to the root and returns `[]`
  * - Non-empty pointers must start with `/`
+ * - `~` must be followed by `0` or `1`
  */
 function tokenize(pointer: string): Array<string> {
   if (pointer === "") return []
   if (pointer.charCodeAt(0) !== 47 /* "/" */) {
     throw new Error(`Invalid JSON Pointer, it must start with "/": ${JSON.stringify(pointer)}`)
   }
+  if (/~(?![01])/.test(pointer)) {
+    throw new Error(`Invalid JSON Pointer escape: ${JSON.stringify(pointer)}`)
+  }
   return pointer.split("/").slice(1).map(unescapeToken)
 }
 

package/src/JsonSchema.ts

@@ -9,6 +9,7 @@
  * @stability stable
  * @since 4.0.0
  */
+import * as InternalJsonSchema from "./internal/jsonSchema.ts"
 import * as InternalRecord from "./internal/record.ts"
 import { formatUriFragment, parseUriFragment } from "./JsonPointer.ts"
 import * as Predicate from "./Predicate.ts"
@@ -416,9 +417,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.
@@ -719,30 +726,14 @@ function transformSchema(
     for (const key of Object.keys(node)) {
       const value = node[key]
       let transformed = value
-      switch (key) {
-        case "$defs":
-        case "properties":
-        case "patternProperties":
-        case "dependentSchemas":
+      switch (InternalJsonSchema.getSubschemaKind(key)) {
+        case "map":
           transformed = mapObject(value, (value) => walk(value, inEmbeddedResource)) ?? value
           break
-        case "allOf":
-        case "anyOf":
-        case "oneOf":
-        case "prefixItems":
+        case "array":
           transformed = Array.isArray(value) ? value.map((value) => walk(value, inEmbeddedResource)) : value
           break
-        case "not":
-        case "additionalProperties":
-        case "propertyNames":
-        case "unevaluatedProperties":
-        case "items":
-        case "contains":
-        case "unevaluatedItems":
-        case "if":
-        case "then":
-        case "else":
-        case "contentSchema":
+        case "schema":
           transformed = walk(value, inEmbeddedResource)
       }
       InternalRecord.assignProperty(out, key, transformed)
@@ -1230,6 +1221,7 @@ function draft07Adapter(source: JsonSchema, context: Context): JsonSchema {
       case "unevaluatedItems":
         unsupported(key, "Draft-07", "the target dialect has no equivalent")
       case "required":
+      case "enum":
         if (Array.isArray(value) && value.length === 0) break
         InternalRecord.assignProperty(out, key, value)
         break
@@ -1255,6 +1247,8 @@ function draft07Adapter(source: JsonSchema, context: Context): JsonSchema {
   convertDependencies(source, out, context, "draft-07")
   convertLegacyId(source, out, "$id", "Draft-07")
 
+  if (Array.isArray(source.enum) && source.enum.length === 0) appendAllOf(out, { not: {} })
+
   convertReference(out, reference, context)
 
   return out
@@ -1331,8 +1325,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 +1372,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,
@@ -1534,30 +1547,14 @@ function hasSchemaIdentifier(node: unknown): boolean {
   if (Object.hasOwn(node, "$id") || Object.hasOwn(node, "$anchor")) return true
   for (const key of Object.keys(node)) {
     const value = node[key]
-    switch (key) {
-      case "$defs":
-      case "properties":
-      case "patternProperties":
-      case "dependentSchemas":
+    switch (InternalJsonSchema.getSubschemaKind(key)) {
+      case "map":
         if (Predicate.isObject(value) && Object.values(value).some(hasSchemaIdentifier)) return true
         break
-      case "allOf":
-      case "anyOf":
-      case "oneOf":
-      case "prefixItems":
+      case "array":
         if (Array.isArray(value) && value.some(hasSchemaIdentifier)) return true
         break
-      case "not":
-      case "additionalProperties":
-      case "propertyNames":
-      case "unevaluatedProperties":
-      case "items":
-      case "contains":
-      case "unevaluatedItems":
-      case "if":
-      case "then":
-      case "else":
-      case "contentSchema":
+      case "schema":
         if (hasSchemaIdentifier(value)) return true
     }
   }

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 ?