effect 4.0.6 → 4.0.7

package/src/Data.ts

@@ -392,13 +392,14 @@ export declare namespace TaggedEnum {
    * @category utility types
    * @since 3.1.0
    */
-  export type Constructor<A extends { readonly _tag: string }> = Types.Simplify<
-    {
+  export type Constructor<A extends { readonly _tag: string }> =
+    & {
       readonly [Tag in A["_tag"]]: ConstructorFrom<
         Extract<A, { readonly _tag: Tag }>,
         "_tag"
       >
-    } & {
+    }
+    & {
       readonly $is: <Tag extends A["_tag"]>(
         tag: Tag
       ) => (u: unknown) => u is Extract<A, { readonly _tag: Tag }>
@@ -424,7 +425,6 @@ export declare namespace TaggedEnum {
         ): Unify<ReturnType<Cases[A["_tag"]]>>
       }
     }
-  >
 
   /**
    * Function type that constructs a tagged-union variant from its fields,
@@ -446,6 +446,61 @@ export declare namespace TaggedEnum {
     args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends Tag ? never : P]: A[P] }>
   ) => A
 
+  /**
+   * The full constructors-and-matchers object type returned by {@link taggedEnum}
+   * for a {@link WithGenerics} definition.
+   *
+   * **When to use**
+   *
+   * Use when you want to annotate an exported constructor bundle for a generic
+   * tagged enum.
+   *
+   * **Details**
+   *
+   * Includes one generic constructor per variant (keyed by tag name) plus the
+   * `$is` / `$match` helpers from {@link GenericMatchers}.
+   *
+   * @see {@link Constructor} — the non-generic equivalent
+   * @see {@link GenericCaseConstructor} — the constructor for one variant
+   *
+   * @category utility types
+   * @since 4.0.7
+   */
+  export type GenericConstructor<Z extends WithGenerics<1 | 2 | 3 | 4>> =
+    & {
+      readonly [Tag in Z["taggedEnum"]["_tag"]]: GenericCaseConstructor<Z, Tag>[Z["numberOfGenerics"]]
+    }
+    & GenericMatchers<Z>
+
+  /**
+   * The generic constructors for one variant of a {@link WithGenerics}
+   * definition, keyed by the number of generics.
+   *
+   * **When to use**
+   *
+   * Use to type an individual constructor for one variant of a generic tagged
+   * enum, by indexing with the definition's `numberOfGenerics`.
+   *
+   * @see {@link GenericConstructor} — the full constructor object type
+   *
+   * @category utility types
+   * @since 4.0.7
+   */
+  export interface GenericCaseConstructor<Z extends WithGenerics<number>, Tag extends Z["taggedEnum"]["_tag"]> {
+    readonly 1: <A>(
+      args: Args<Kind<Z, A>, Tag, Extract<Kind<Z, A>, { readonly _tag: Tag }>>
+    ) => Value<Kind<Z, A>, Tag>
+    readonly 2: <A, B>(
+      args: Args<Kind<Z, A, B>, Tag, Extract<Kind<Z, A, B>, { readonly _tag: Tag }>>
+    ) => Value<Kind<Z, A, B>, Tag>
+    readonly 3: <A, B, C>(
+      args: Args<Kind<Z, A, B, C>, Tag, Extract<Kind<Z, A, B, C>, { readonly _tag: Tag }>>
+    ) => Value<Kind<Z, A, B, C>, Tag>
+    readonly 4: <A, B, C, D>(
+      args: Args<Kind<Z, A, B, C, D>, Tag, Extract<Kind<Z, A, B, C, D>, { readonly _tag: Tag }>>
+    ) => Value<Kind<Z, A, B, C, D>, Tag>
+  }
+
   /**
    * Type-guard and pattern-matching interface for generic tagged enums.
    *
@@ -655,267 +710,7 @@ export const taggedEnum: {
    * @category constructors
    * @since 2.0.0
    */
-  <Z extends TaggedEnum.WithGenerics<1>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  /**
-   * Creates constructors and matchers for a `TaggedEnum` type.
-   *
-   * **When to use**
-   *
-   * Use when you model a closed union with plain data objects and want
-   * construction, tag checks, and exhaustive matching from the same definition.
-   *
-   * **Details**
-   *
-   * Returns an object with:
-   * - One constructor per variant (keyed by tag name)
-   * - `$is(tag)` — returns a type-guard function that checks only the `_tag` field
-   * - `$match` — exhaustive pattern matching (data-first or data-last)
-   *
-   * **Gotchas**
-   *
-   * - Constructors produce **plain objects**, not class instances.
-   * - `$is(tag)` only checks the `_tag` field, not the full structure. It relies
-   *   on the tag being globally unique and the value being produced by your
-   *   constructors. For untrusted input, validate with the `Schema` module first.
-   *
-   * **Example** (Creating and matching tagged enum values)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type HttpError = Data.TaggedEnum<{
-   *   BadRequest: { readonly message: string }
-   *   NotFound: { readonly url: string }
-   * }>
-   *
-   * const { BadRequest, NotFound, $is, $match } = Data.taggedEnum<HttpError>()
-   *
-   * const err = NotFound({ url: "/missing" })
-   *
-   * $is("NotFound")(err) // => true
-   *
-   * $match(err, {
-   *   BadRequest: (e) => e.message,
-   *   NotFound: (e) => `${e.url} not found`
-   * }) // => "/missing not found"
-   * ```
-   *
-   * **Example** (Defining a generic tagged enum)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type MyResult<E, A> = Data.TaggedEnum<{
-   *   Failure: { readonly error: E }
-   *   Success: { readonly value: A }
-   * }>
-   * interface MyResultDef extends Data.TaggedEnum.WithGenerics<2> {
-   *   readonly taggedEnum: MyResult<this["A"], this["B"]>
-   * }
-   * const { Failure, Success } = Data.taggedEnum<MyResultDef>()
-   *
-   * const ok = Success({ value: 42 })
-   * // ok: { readonly _tag: "Success"; readonly value: number }
-   * ok // => { value: 42, _tag: "Success" }
-   * ```
-   *
-   * @see {@link TaggedEnum} — the type-level companion
-   * @see {@link TaggedEnum.Constructor} — the returned object type
-   * @see {@link TaggedEnum.WithGenerics} — generic enum support
-   *
-   * @stability stable
-   * @category constructors
-   * @since 2.0.0
-   */
-  <Z extends TaggedEnum.WithGenerics<2>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A, B>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A, B>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  /**
-   * Creates constructors and matchers for a `TaggedEnum` type.
-   *
-   * **When to use**
-   *
-   * Use when you model a closed union with plain data objects and want
-   * construction, tag checks, and exhaustive matching from the same definition.
-   *
-   * **Details**
-   *
-   * Returns an object with:
-   * - One constructor per variant (keyed by tag name)
-   * - `$is(tag)` — returns a type-guard function that checks only the `_tag` field
-   * - `$match` — exhaustive pattern matching (data-first or data-last)
-   *
-   * **Gotchas**
-   *
-   * - Constructors produce **plain objects**, not class instances.
-   * - `$is(tag)` only checks the `_tag` field, not the full structure. It relies
-   *   on the tag being globally unique and the value being produced by your
-   *   constructors. For untrusted input, validate with the `Schema` module first.
-   *
-   * **Example** (Creating and matching tagged enum values)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type HttpError = Data.TaggedEnum<{
-   *   BadRequest: { readonly message: string }
-   *   NotFound: { readonly url: string }
-   * }>
-   *
-   * const { BadRequest, NotFound, $is, $match } = Data.taggedEnum<HttpError>()
-   *
-   * const err = NotFound({ url: "/missing" })
-   *
-   * $is("NotFound")(err) // => true
-   *
-   * $match(err, {
-   *   BadRequest: (e) => e.message,
-   *   NotFound: (e) => `${e.url} not found`
-   * }) // => "/missing not found"
-   * ```
-   *
-   * **Example** (Defining a generic tagged enum)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type MyResult<E, A> = Data.TaggedEnum<{
-   *   Failure: { readonly error: E }
-   *   Success: { readonly value: A }
-   * }>
-   * interface MyResultDef extends Data.TaggedEnum.WithGenerics<2> {
-   *   readonly taggedEnum: MyResult<this["A"], this["B"]>
-   * }
-   * const { Failure, Success } = Data.taggedEnum<MyResultDef>()
-   *
-   * const ok = Success({ value: 42 })
-   * // ok: { readonly _tag: "Success"; readonly value: number }
-   * ok // => { value: 42, _tag: "Success" }
-   * ```
-   *
-   * @see {@link TaggedEnum} — the type-level companion
-   * @see {@link TaggedEnum.Constructor} — the returned object type
-   * @see {@link TaggedEnum.WithGenerics} — generic enum support
-   *
-   * @stability stable
-   * @category constructors
-   * @since 2.0.0
-   */
-  <Z extends TaggedEnum.WithGenerics<3>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A, B, C>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A, B, C>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  /**
-   * Creates constructors and matchers for a `TaggedEnum` type.
-   *
-   * **When to use**
-   *
-   * Use when you model a closed union with plain data objects and want
-   * construction, tag checks, and exhaustive matching from the same definition.
-   *
-   * **Details**
-   *
-   * Returns an object with:
-   * - One constructor per variant (keyed by tag name)
-   * - `$is(tag)` — returns a type-guard function that checks only the `_tag` field
-   * - `$match` — exhaustive pattern matching (data-first or data-last)
-   *
-   * **Gotchas**
-   *
-   * - Constructors produce **plain objects**, not class instances.
-   * - `$is(tag)` only checks the `_tag` field, not the full structure. It relies
-   *   on the tag being globally unique and the value being produced by your
-   *   constructors. For untrusted input, validate with the `Schema` module first.
-   *
-   * **Example** (Creating and matching tagged enum values)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type HttpError = Data.TaggedEnum<{
-   *   BadRequest: { readonly message: string }
-   *   NotFound: { readonly url: string }
-   * }>
-   *
-   * const { BadRequest, NotFound, $is, $match } = Data.taggedEnum<HttpError>()
-   *
-   * const err = NotFound({ url: "/missing" })
-   *
-   * $is("NotFound")(err) // => true
-   *
-   * $match(err, {
-   *   BadRequest: (e) => e.message,
-   *   NotFound: (e) => `${e.url} not found`
-   * }) // => "/missing not found"
-   * ```
-   *
-   * **Example** (Defining a generic tagged enum)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type MyResult<E, A> = Data.TaggedEnum<{
-   *   Failure: { readonly error: E }
-   *   Success: { readonly value: A }
-   * }>
-   * interface MyResultDef extends Data.TaggedEnum.WithGenerics<2> {
-   *   readonly taggedEnum: MyResult<this["A"], this["B"]>
-   * }
-   * const { Failure, Success } = Data.taggedEnum<MyResultDef>()
-   *
-   * const ok = Success({ value: 42 })
-   * // ok: { readonly _tag: "Success"; readonly value: number }
-   * ok // => { value: 42, _tag: "Success" }
-   * ```
-   *
-   * @see {@link TaggedEnum} — the type-level companion
-   * @see {@link TaggedEnum.Constructor} — the returned object type
-   * @see {@link TaggedEnum.WithGenerics} — generic enum support
-   *
-   * @stability stable
-   * @category constructors
-   * @since 2.0.0
-   */
-  <Z extends TaggedEnum.WithGenerics<4>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C, D>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A, B, C, D>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C, D>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
+  <Z extends TaggedEnum.WithGenerics<1 | 2 | 3 | 4>>(): TaggedEnum.GenericConstructor<Z>
   /**
    * Creates constructors and matchers for a `TaggedEnum` type.
    *

package/src/Effect.ts

@@ -19017,7 +19017,7 @@ export const runSyncWith: <R>(
  * import { Cause, Effect, Exit } from "effect"
  *
  * const exit = Effect.runSyncExit(Effect.promise(() => Promise.resolve(1)))
- * const isAsyncDie = Exit.hasDies(exit) && exit.cause.reasons.some(
+ * const isAsyncDie = Exit.isFailure(exit) && Exit.hasDies(exit) && exit.cause.reasons.some(
  *   (reason) => Cause.isDieReason(reason) && Cause.isAsyncFiberError(reason.defect)
  * )
  *

package/src/Equal.ts

@@ -12,7 +12,7 @@
  */
 import type { Equivalence } from "./Equivalence.ts"
 import * as Hash from "./Hash.ts"
-import { byReferenceInstances, getAllObjectKeys, viewBytes } from "./internal/equal.ts"
+import { bufferBytes, byReferenceInstances, getAllObjectKeys, isArrayBufferLike, viewBytes } from "./internal/equal.ts"
 import { hasProperty } from "./Predicate.ts"
 
 /**
@@ -257,6 +257,13 @@ function compareStructure(self: object, that: object): boolean {
       return false
     }
     return compareArrays(self, that)
+  } else if (isArrayBufferLike(self)) {
+    if (!isArrayBufferLike(that) || (self instanceof ArrayBuffer) !== (that instanceof ArrayBuffer)) {
+      return false
+    }
+    const selfBytes = bufferBytes(self)
+    const thatBytes = bufferBytes(that)
+    return selfBytes !== undefined && thatBytes !== undefined && compareTypedArrays(selfBytes, thatBytes)
   } else if (ArrayBuffer.isView(self)) {
     const selfIsDataView = self instanceof DataView
     if (

package/src/Exit.ts

@@ -463,7 +463,7 @@ export const isFailure: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effe
  * @category guards
  * @since 4.0.0
  */
-export const hasFails: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect.exitHasFails
+export const hasFails: <A, E>(self: Exit<A, E>) => boolean = effect.exitHasFails
 
 /**
  * Checks whether a failed Exit contains defects (Die reasons).
@@ -494,7 +494,7 @@ export const hasFails: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effec
  * @category guards
  * @since 4.0.0
  */
-export const hasDies: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect.exitHasDies
+export const hasDies: <A, E>(self: Exit<A, E>) => boolean = effect.exitHasDies
 
 /**
  * Checks whether a failed Exit contains interruptions (Interrupt reasons).
@@ -525,7 +525,7 @@ export const hasDies: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect
  * @category guards
  * @since 4.0.0
  */
-export const hasInterrupts: <A, E>(self: Exit<A, E>) => self is Failure<A, E> = effect.exitHasInterrupts
+export const hasInterrupts: <A, E>(self: Exit<A, E>) => boolean = effect.exitHasInterrupts
 
 /**
  * Extracts the Success variant from an Exit as a Result.

package/src/Formatter.ts

@@ -309,10 +309,11 @@ export function formatJson(input: unknown, options?: {
   readonly space?: number | string | undefined
 }): string {
   const ancestors: Array<object> = []
+  const sources = new WeakMap<object, object>()
   return JSON.stringify(
     input,
     function(this: object, key: string, value: unknown) {
-      const original = Object.getOwnPropertyDescriptor(this, key)?.value
+      const original = Object.getOwnPropertyDescriptor(sources.get(this) ?? this, key)?.value
       const redacted = Predicate.hasProperty(original, symbolRedactable)
         ? redact(original)
         : redact(value)
@@ -339,18 +340,10 @@ export function formatJson(input: unknown, options?: {
       if (!hasGetter(current) || isJsonPrimitiveWrapper(current)) {
         return current
       }
-      // JSON.stringify reads a getter once, then calls toJSON on the result
-      // before the replacer sees it. Intercept that read to redact the value
-      // first, instead of re-reading the getter in the replacer, which could
-      // repeat side effects or return a different value.
-      const serialized = new Proxy(current, {
-        get(target, key) {
-          const value = Reflect.get(target, key, target)
-          return Object.getOwnPropertyDescriptor(target, key)?.get !== undefined ? redact(value) : value
-        }
-      })
-      ancestors.push(serialized)
-      return serialized
+      const view = redactingView(current)
+      sources.set(view, current)
+      ancestors.push(view)
+      return view
     },
     options?.space
   ) ?? "null"
@@ -365,6 +358,28 @@ function hasGetter(object: object): boolean {
   return false
 }
 
+// JSON.stringify reads a getter once, then calls toJSON on the result before
+// the replacer sees it, so getter results are redacted at the read. A Proxy
+// would do, but not every engine has one, so each key becomes a getter that
+// reads the source lazily, with the source as receiver.
+function redactingView(object: object): object {
+  const view = Array.isArray(object) ? [] : {}
+  // JSON.stringify reads every array index, regardless of enumerability
+  const keys = Array.isArray(object)
+    ? Array.from({ length: object.length }, (_, i) => String(i))
+    : Object.keys(object)
+  for (const key of keys) {
+    Object.defineProperty(view, key, {
+      enumerable: true,
+      get: () => {
+        const value = Reflect.get(object, key)
+        return Object.getOwnPropertyDescriptor(object, key)?.get !== undefined ? redact(value) : value
+      }
+    })
+  }
+  return view
+}
+
 function isJsonPrimitiveWrapper(object: object): boolean {
   // Built-in valueOf checks internal slots across realms without calling user code.
   for (const valueOf of [Number.prototype.valueOf, Boolean.prototype.valueOf, String.prototype.valueOf]) {

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/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"
@@ -725,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)
@@ -1236,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
@@ -1261,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
@@ -1559,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/Metric.ts

@@ -576,7 +576,7 @@ export interface GaugeState<in Input extends number | bigint> {
  *         start: 1,
  *         factor: 2,
  *         count: 10
- *       }) // 1, 2, 4, 8, ..., 512
+ *       }) // 1, 2, 4, 8, ..., 256, Infinity
  *     }
  *   )
  *
@@ -696,8 +696,8 @@ export interface Histogram<Input> extends Metric<Input, HistogramState> {}
  *       totalRequests: state.count, // 5
  *       fastestResponse: state.min, // 50
  *       slowestResponse: state.max, // 750
- *       averageResponse: state.sum / state.count, // 268
- *       totalTime: state.sum, // 1340
+ *       averageResponse: state.sum / state.count, // 259
+ *       totalTime: state.sum, // 1295
  *       distribution: bucketAnalysis
  *       // Example distribution:
  *       // [{ range: "0-100ms", count: 2, percentage: 40.0 },

package/src/MutableList.ts

@@ -9,7 +9,6 @@
  * @stability stable
  * @since 4.0.0
  */
-import * as Arr from "./Array.ts"
 import * as Count from "./internal/count.ts"
 
 /**
@@ -259,7 +258,8 @@ export const prepend = <A>(self: MutableList<A>, message: A): void => {
 /**
  * Prepends all elements from an iterable to the beginning of the MutableList.
  * The elements are added in order, so the first element in the iterable becomes
- * the new head of the list.
+ * the new head of the list. The elements are copied, so the input can be reused
+ * afterward. Use `prependAllUnsafe` to transfer ownership of an array instead.
  *
  * **Example** (Prepending multiple elements)
  *
@@ -279,7 +279,7 @@ export const prepend = <A>(self: MutableList<A>, message: A): void => {
  * @since 4.0.0
  */
 export const prependAll = <A>(self: MutableList<A>, messages: Iterable<A>): void =>
-  prependAllUnsafe(self, Arr.fromIterable(messages), !Array.isArray(messages))
+  prependAllUnsafe(self, Array.from(messages), true)
 
 /**
  * Prepends all elements from a ReadonlyArray to the beginning of the MutableList.
@@ -328,7 +328,9 @@ export const prependAllUnsafe = <A>(self: MutableList<A>, messages: ReadonlyArra
 
 /**
  * Appends all elements from an iterable to the end of the MutableList.
- * Returns the number of elements added.
+ * Returns the number of elements added. The elements are copied, so the input
+ * can be reused afterward. Use `appendAllUnsafe` to transfer ownership of an
+ * array instead.
  *
  * **Example** (Appending multiple elements)
  *
@@ -349,7 +351,7 @@ export const prependAllUnsafe = <A>(self: MutableList<A>, messages: ReadonlyArra
  * @since 4.0.0
  */
 export const appendAll = <A>(self: MutableList<A>, messages: Iterable<A>): number =>
-  appendAllUnsafe(self, Arr.fromIterable(messages), !Array.isArray(messages))
+  appendAllUnsafe(self, Array.from(messages), true)
 
 /**
  * Appends all elements from a ReadonlyArray to the end of the MutableList.