effect 4.0.6 → 4.0.7

package/src/MutableRef.ts

@@ -12,6 +12,7 @@
  */
 import * as Equal from "./Equal.ts"
 import * as Dual from "./Function.ts"
+import * as Hash from "./Hash.ts"
 import { type Inspectable, toJson } from "./Inspectable.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -74,9 +75,15 @@ export interface MutableRef<out T> extends Pipeable, Inspectable {
   current: T
 }
 
-const MutableRefProto: Omit<MutableRef<unknown>, "current"> = {
+const MutableRefProto: Omit<MutableRef<unknown>, "current"> & Equal.Equal = {
   [TypeId]: TypeId,
   ...PipeInspectableProto,
+  [Equal.symbol](that: unknown): boolean {
+    return this === that
+  },
+  [Hash.symbol](): number {
+    return Hash.random(this)
+  },
   toJSON<A>(this: MutableRef<A>) {
     return {
       _id: "MutableRef",

package/src/PartitionedSemaphore.ts

@@ -59,7 +59,8 @@ export type PartitionedTypeId = "~effect/PartitionedSemaphore"
  *
  * **Details**
  *
- * Waiting permits are distributed across partitions in round-robin order.
+ * Waiters are served across partitions in round-robin order, completing each
+ * waiter's permit request before moving to the next partition.
  *
  * @stability unstable
  * @category models
@@ -150,6 +151,7 @@ export const makeUnsafe = <K = unknown>(options: {
   let iterator = partitions[Symbol.iterator]()
   let releasing = false
   let pendingPermits = 0
+  let partial: Waiter | undefined
 
   const releaseUnsafe = (permits: number): number => {
     if (permits > 0) {
@@ -162,26 +164,32 @@ export const makeUnsafe = <K = unknown>(options: {
       releasing = true
       try {
         while (pendingPermits > 0 && waitingPermits > 0) {
-          let state = iterator.next()
-          if (state.done) {
-            iterator = partitions[Symbol.iterator]()
-            state = iterator.next()
+          let waiter = partial
+          if (waiter === undefined) {
+            let state = iterator.next()
             if (state.done) {
-              break
+              iterator = partitions[Symbol.iterator]()
+              state = iterator.next()
+              if (state.done) {
+                break
+              }
             }
-          }
 
-          const waiter = state.value[1].values().next().value
-          if (waiter === undefined) {
-            continue
+            waiter = state.value[1].values().next().value
+            if (waiter === undefined) {
+              continue
+            }
           }
 
-          waiter.permits -= 1
-          waitingPermits -= 1
-          pendingPermits -= 1
+          const granted = Math.min(waiter.permits, pendingPermits)
+          waiter.permits -= granted
+          waitingPermits -= granted
+          pendingPermits -= granted
 
           if (waiter.permits === 0) {
             waiter.resume()
+          } else {
+            partial = waiter
           }
         }
       } finally {
@@ -249,6 +257,9 @@ export const makeUnsafe = <K = unknown>(options: {
         }
 
         const cleanup = () => {
+          if (partial === entry) {
+            partial = undefined
+          }
           if (waiters.delete(entry) && waiters.size === 0) {
             MutableHashMap.remove(partitions, key)
           }

package/src/Pool.ts

@@ -463,7 +463,7 @@ export const get = <A, E>(self: Pool<A, E>): Effect.Effect<A, E, Scope.Scope> =>
   core.withFiber((fiber) => {
     const state = self.state
     if (state.isShuttingDown) return internal.interrupt
-    if (state.availableHead?.exit._tag === "Success") {
+    if (state.waiters.size === 0 && state.availableHead?.exit._tag === "Success") {
       state.usage++
       if (self.config.isFixed || targetSize(self) <= activeSize(self)) {
         return leaseItem(self, state.availableHead, fiber)
@@ -570,7 +570,7 @@ export const use: {
   core.withFiber((fiber) => {
     const state = self.state
     if (state.isShuttingDown) return internal.interrupt
-    if (state.availableHead?.exit._tag === "Success") {
+    if (state.waiters.size === 0 && state.availableHead?.exit._tag === "Success") {
       state.usage++
       if (self.config.isFixed || targetSize(self) <= activeSize(self)) {
         return useItem(self, state.availableHead, f, fiber)
@@ -611,12 +611,18 @@ const getSlowWith = <A, E, X, R>(
   internal.uninterruptibleMask((restore) => {
     const state = self.state
     state.usage++
+    const waiter = makeWaiter<A, E>()
     const wait: Effect.Effect<X, any, R> = internal.flatMap(
       internal.onError(
-        restore(waitForItem(self)),
+        restore(waitForItem(self, waiter)),
         () =>
-          internal.sync(() => {
+          core.withFiber((fiber) => {
             state.usage--
+            // Only a woken waiter is still registered here: one cancelled while
+            // asleep already left. It passes its wake on, so the capacity it was
+            // woken for is not stranded.
+            if (state.waiters.delete(waiter)) wakeWaiters(self, fiber, 1)
+            return internal.void
           })
       ),
       () => loop
@@ -626,6 +632,12 @@ const getSlowWith = <A, E, X, R>(
         state.usage--
         return internal.interrupt
       }
+      // A borrower that has not waited yet queues behind the borrowers already
+      // waiting. Waiters keep their place until they take an item, so this
+      // also holds while a woken waiter has yet to run.
+      if (state.waiters.size > 0 && !state.waiters.has(waiter)) {
+        return wait
+      }
       // Replace failed slots only when the pool cannot grow.
       const item = firstHealthyAvailable(self) ??
         (targetSize(self) <= activeSize(self) ? state.availableHead : undefined)
@@ -636,6 +648,7 @@ const getSlowWith = <A, E, X, R>(
         removeFailedItem(self, item)
         return loop
       }
+      state.waiters.delete(waiter)
       return lease(self, item, fiber, restore)
     })
     const loop: Effect.Effect<X, any, R> = internal.suspend(() => {
@@ -718,19 +731,49 @@ const firstHealthyAvailable = <A, E>(self: Pool<A, E>): PoolItem<A, E> | undefin
   return item
 }
 
-const waitForItem = <A, E>(self: Pool<A, E>): Effect.Effect<void, E> =>
+/**
+ * A borrower's entry in `State.waiters`. It stays registered from the first
+ * wait until the borrower takes an item or leaves, so the borrower keeps its
+ * place in the queue across wakes.
+ *
+ * `resume` is set while the borrower is asleep. A registered waiter without
+ * one has been woken and has yet to take an item, wait again or leave.
+ */
+interface Waiter<A, E> {
+  (failure?: Exit.Failure<A, E>): void
+  resume: ((effect: Effect.Effect<void, E>) => void) | undefined
+}
+
+const makeWaiter = <A, E>(): Waiter<A, E> => {
+  const waiter = ((failure?: Exit.Failure<A, E>) => {
+    const resume = waiter.resume
+    if (resume === undefined) return
+    waiter.resume = undefined
+    resume(failure ?? internal.void)
+  }) as Waiter<A, E>
+  waiter.resume = undefined
+  return waiter
+}
+
+const waitForItem = <A, E>(self: Pool<A, E>, waiter: Waiter<A, E>): Effect.Effect<void, E> =>
   internal.callback((resume) => {
     const state = self.state
-    if (firstHealthyAvailable(self) !== undefined || state.isShuttingDown) {
+    if (
+      state.isShuttingDown ||
+      (state.waiters.size === 0 && firstHealthyAvailable(self) !== undefined)
+    ) {
       return resume(internal.void)
     }
-    const observer = (failure?: Exit.Failure<A, E>) => {
-      state.waiters.delete(observer)
-      resume(failure ?? internal.void)
-    }
-    state.waiters.add(observer)
+    waiter.resume = resume
+    // Re-adding a registered waiter keeps its position.
+    state.waiters.add(waiter)
     return internal.sync(() => {
-      state.waiters.delete(observer)
+      // Cancelled while asleep: leave at once, so no wake or failure is spent
+      // on it. Cancelled after a wake: stay until the wake is passed on.
+      if (waiter.resume !== undefined) {
+        waiter.resume = undefined
+        state.waiters.delete(waiter)
+      }
     })
   })
 
@@ -738,23 +781,36 @@ const wakeWaiters = <A, E>(self: Pool<A, E>, fiber: Fiber.Fiber<unknown, unknown
   const waiters = self.state.waiters
   if (waiters.size === 0) return
   fiber.currentDispatcher.scheduleTask(() => {
+    // Walk the live set, so a waiter that leaves during the walk does not use
+    // up a wake. Skip waiters already woken, and stop once nothing is left to
+    // take.
     let remaining = count
-    const toWake: Array<(failure?: Exit.Failure<A, E>) => void> = []
     for (const notify of waiters) {
-      if (remaining-- <= 0) break
-      toWake.push(notify)
-    }
-    for (let i = 0; i < toWake.length; i++) {
-      toWake[i]()
+      if (remaining <= 0 || self.state.availableHead === undefined) break
+      if ((notify as Waiter<A, E>).resume === undefined) continue
+      remaining--
+      notify()
     }
   }, 0)
 }
 
-const wakeAll = <A, E>(self: Pool<A, E>): Effect.Effect<void> =>
-  core.withFiber((fiber) => {
-    wakeWaiters(self, fiber, Number.POSITIVE_INFINITY)
-    return internal.void
-  })
+const firstSleepingWaiter = <A, E>(self: Pool<A, E>) => {
+  for (const notify of self.state.waiters) {
+    if ((notify as Waiter<A, E>).resume !== undefined) return notify
+  }
+  return undefined
+}
+
+// Wakes every waiter so it can retry after a failed acquisition. A waiter that
+// could not start a resize while another was running depends on this. Waking
+// a waiter that is already awake is a no-op.
+const wakeAll = <A, E>(self: Pool<A, E>, fiber: Fiber.Fiber<unknown, unknown>) => {
+  const waiters = self.state.waiters
+  if (waiters.size === 0) return
+  fiber.currentDispatcher.scheduleTask(() => {
+    for (const notify of Array.from(waiters)) notify()
+  }, 0)
+}
 
 // Reservations prevent reuse without extending the lifetime of borrowed items.
 const reservations = new WeakMap<PoolItem<unknown, unknown>, number>()
@@ -1005,22 +1061,38 @@ const resizeLoop = <A, E>(self: Pool<A, E>): Effect.Effect<void> =>
       return Effect.void
     }
     const toAcquire = target - active
-    const acquireOne = self.config.strategy === strategyNoop
-      ? allocate(self)
-      : Effect.flatMap(
-        self.config.strategy.reclaim(self),
-        (item) => item ? Effect.succeed(item) : allocate(self)
-      )
+    // Wake waiters as each item arrives. Waiting for the whole batch would
+    // leave acquired items idle behind a slow acquisition, with every borrower
+    // queued behind the waiters.
+    const acquireOne = Effect.tap(
+      self.config.strategy === strategyNoop
+        ? allocate(self)
+        : Effect.flatMap(
+          self.config.strategy.reclaim(self),
+          (item) =>
+            item
+              ? Effect.sync(() => {
+                // A reclaimed item rejoins circulation like a released one.
+                if (self.state.items.has(item) && !self.state.invalidated.has(item)) addAvailableFront(self, item)
+                return item
+              })
+              : allocate(self)
+        ),
+      (item) =>
+        core.withFiber((fiber) => {
+          // A failed acquisition wakes everyone so they can retry it. A new
+          // item can only serve as many waiters as it has slots.
+          if (item.exit._tag === "Failure") wakeAll(self, fiber)
+          else wakeWaiters(self, fiber, self.config.concurrency)
+          return internal.void
+        })
+    )
     if (toAcquire === 1) {
-      const acquired = Effect.tap(acquireOne, wakeAll(self))
       return self.config.isFixed
-        ? Effect.asVoid(acquired)
-        : Effect.flatMap(acquired, (item) => item.exit._tag === "Failure" ? Effect.void : resizeLoop(self))
+        ? Effect.asVoid(acquireOne)
+        : Effect.flatMap(acquireOne, (item) => item.exit._tag === "Failure" ? Effect.void : resizeLoop(self))
     }
-    const acquired = acquireOne.pipe(
-      Effect.replicateEffect(toAcquire, { concurrency: toAcquire }),
-      Effect.tap(wakeAll(self))
-    )
+    const acquired = Effect.replicateEffect(acquireOne, toAcquire, { concurrency: toAcquire })
     return self.config.isFixed
       ? Effect.asVoid(acquired)
       : Effect.flatMap(
@@ -1059,7 +1131,7 @@ const allocate = <A, E>(self: Pool<A, E>): Effect.Effect<PoolItem<A, E>> =>
           return self.config.strategy === strategyNoop ? Effect.succeed(item) : Effect.as(onAcquire, item)
         }
         // Deliver a waiting borrower its own failure; otherwise retain the slot.
-        const waiter = firstHealthyAvailable(self) === undefined ? self.state.waiters.values().next().value : undefined
+        const waiter = firstHealthyAvailable(self) === undefined ? firstSleepingWaiter(self) : undefined
         if (waiter !== undefined) {
           waiter(exit)
         } else {

package/src/PubSub.ts

@@ -3129,14 +3129,13 @@ export class BackPressureStrategy<in out A> implements PubSub.Strategy<A> {
       if (publisher === MutableList.Empty) {
         keepPolling = false
       } else {
-        const [value, deferred] = publisher
+        const [value, deferred, last] = publisher
         const published = pubsub.publish(value)
-        if (published && publisher[2]) {
-          Deferred.doneUnsafe(deferred, Exit.succeed(true))
-        } else if (!published) {
-          MutableList.prepend(this.publishers, publisher)
-        }
+        if (!published) MutableList.prepend(this.publishers, publisher)
         this.completeSubscribersUnsafe(pubsub, subscribers)
+        // Resuming the publisher can synchronously end the PubSub, so notify
+        // waiting subscribers first.
+        if (published && last) Deferred.doneUnsafe(deferred, Exit.succeed(true))
       }
     }
   }

package/src/Ref.ts

@@ -12,7 +12,9 @@
  * @since 2.0.0
  */
 import * as Effect from "./Effect.ts"
+import * as Equal from "./Equal.ts"
 import { dual, identity } from "./Function.ts"
+import * as Hash from "./Hash.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as MutableRef from "./MutableRef.ts"
 import type * as Option from "./Option.ts"
@@ -110,6 +112,12 @@ const RefProto = {
     _A: identity
   },
   ...PipeInspectableProto,
+  [Equal.symbol](that: unknown): boolean {
+    return this === that
+  },
+  [Hash.symbol](): number {
+    return Hash.random(this)
+  },
   toJSON(this: Ref<any>) {
     return {
       _id: "Ref",

package/src/Schedule.ts

@@ -1071,10 +1071,10 @@ export const fibonacci = (one: Duration.Input): Schedule<Duration.Duration> => {
     let a = 0
     let b = oneMillis
     return constant(effect.sync(() => {
+      const duration = Duration.millis(b)
       const next = a + b
       a = b
       b = next
-      const duration = Duration.millis(next)
       return [duration, duration]
     }))
   }))

package/src/Schema.ts

@@ -3983,11 +3983,18 @@ export interface $Record<Key extends Record.Key, Value extends Constraint> exten
  *
  * **Gotchas**
  *
+ * Dynamic records reject value schemas wrapped with {@link optionalKey} or
+ * {@link optional}. Index signatures already allow keys to be absent; use
+ * {@link UndefinedOr} when existing entries may contain `undefined`. Optional
+ * value schemas remain valid for finite literal keys, which become declared
+ * properties.
+ *
  * When decoded or encoded key transformations produce the same property key,
  * sequential parsing applies selected own properties in selection order, so
  * the later selected property overwrites the earlier value. Dynamic key
- * selection always examines own properties. Finite literal keys are declared
- * fields and may therefore be inherited. Output key order is not guaranteed.
+ * selection always examines own properties. Finite literal and enum keys are
+ * declared fields and may therefore be inherited. Output key order is not
+ * guaranteed.
  *
  * **Example** (Defining a string-keyed record of numbers)
  *
@@ -6737,9 +6744,8 @@ export function link<T>() {
  * )
  *
  * const result = Schema.decodeUnknownResult(schema)({ password: "123456", confirmPassword: "1234567" })
- * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Pointer") {
- *   result.failure.issue.issue.path // => ["password"]
- * }
+ * const message = Result.isFailure(result) ? result.failure.message : ""
+ * message // => "password and confirmPassword must match\n  at [\"password\"]"
  * ```
  *
  * **Example** (Reporting multiple failures at once)
@@ -6759,9 +6765,8 @@ export function link<T>() {
  * )
  *
  * const result = Schema.decodeUnknownResult(schema)({ a: 1, b: 0, c: 0 })
- * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Composite") {
- *   result.failure.issue.issue.issues.map((issue) => issue._tag === "Pointer" ? issue.path : []) // => [["b"], ["c"]]
- * }
+ * const message = Result.isFailure(result) ? result.failure.message : ""
+ * message // => "b must be greater than 0\n  at [\"b\"]\nc must be greater than 0\n  at [\"c\"]"
  * ```
  *
  * @stability stable
@@ -6904,8 +6909,8 @@ export function isPattern(
   const flags = regExp.flags
   const canExport = /^[dg]*uy?$/.test(flags)
   const runtimeRegExp = flags === ""
-    ? `new RegExp(${format(source)})`
-    : `new RegExp(${format(source)}, ${format(flags)})`
+    ? `new globalThis.RegExp(${format(source)})`
+    : `new globalThis.RegExp(${format(source)}, ${format(flags)})`
   return SchemaAST.isPattern(regExp, {
     toJsonSchema: () => canExport ? { pattern: flags.endsWith("y") ? `^(?:${source})` : source } : [{}, true],
     toCode: () => ({ runtime: `Schema.isPattern(${runtimeRegExp})` }),
@@ -7037,7 +7042,7 @@ export function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotations?: An
   )
 }
 
-const GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/
+const GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/u
 /**
  * Validates that a string has the GUID / UUID textual shape.
  *
@@ -7072,18 +7077,22 @@ export function isGUID(annotations?: Annotations.Filter) {
         id: "effect/schema/isGUID",
         payload: null
       },
-      toJsonSchema: () => ({ pattern: GUID_REGEXP.source }),
       toCode: () => ({ runtime: "Schema.isGUID()" }),
       ...annotations
     }
   )
 }
+
+const ULID_REGEXP = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/u
 /**
  * Validates that a string is a valid ULID (Universally Unique Lexicographically
  * Sortable Identifier).
  *
  * **Details**
  *
+ * Accepts uppercase and lowercase characters. The first character must be
+ * between `0` and `7` so the value fits in 128 bits.
+ *
  * JSON Schema:
  *
  * This check corresponds to a `pattern` constraint in JSON Schema that matches
@@ -7099,15 +7108,13 @@ export function isGUID(annotations?: Annotations.Filter) {
  * @since 4.0.0
  */
 export function isULID(annotations?: Annotations.Filter) {
-  const regExp = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/
   return isPattern(
-    regExp,
+    ULID_REGEXP,
     {
       representation: {
         id: "effect/schema/isULID",
         payload: null
       },
-      toJsonSchema: () => ({ pattern: regExp.source }),
       toCode: () => ({ runtime: "Schema.isULID()" }),
       ...annotations
     }
@@ -7392,16 +7399,18 @@ const CAPITALIZED_PATTERN = "^(?:[^a-z][\\s\\S]*)?$"
  * @since 4.0.0
  */
 export function isCapitalized(annotations?: Annotations.Filter) {
-  const regExp = new globalThis.RegExp(CAPITALIZED_PATTERN)
   return makeFilter(
-    (s: string) => s.charAt(0).toUpperCase() === s.charAt(0),
+    (s: string) => {
+      const [first = ""] = s
+      return first.toUpperCase() === first
+    },
     {
       expected: "a string with the first character in uppercase",
       representation: {
         id: "effect/schema/isCapitalized",
         payload: null
       },
-      toJsonSchema: () => [{ pattern: regExp.source }, true],
+      toJsonSchema: () => [{ pattern: CAPITALIZED_PATTERN }, true],
       toCode: () => ({ runtime: "Schema.isCapitalized()" }),
       arbitraryConstraint: {
         patterns: [{ source: CAPITALIZED_PATTERN, flags: "" }]
@@ -7426,16 +7435,18 @@ const UNCAPITALIZED_PATTERN = "^(?:[^A-Z][\\s\\S]*)?$"
  * @since 4.0.0
  */
 export function isUncapitalized(annotations?: Annotations.Filter) {
-  const regExp = new globalThis.RegExp(UNCAPITALIZED_PATTERN)
   return makeFilter(
-    (s: string) => s.charAt(0).toLowerCase() === s.charAt(0),
+    (s: string) => {
+      const [first = ""] = s
+      return first.toLowerCase() === first
+    },
     {
       expected: "a string with the first character in lowercase",
       representation: {
         id: "effect/schema/isUncapitalized",
         payload: null
       },
-      toJsonSchema: () => [{ pattern: regExp.source }, true],
+      toJsonSchema: () => [{ pattern: UNCAPITALIZED_PATTERN }, true],
       toCode: () => ({ runtime: "Schema.isUncapitalized()" }),
       arbitraryConstraint: {
         patterns: [{ source: UNCAPITALIZED_PATTERN, flags: "" }]
@@ -8064,7 +8075,7 @@ function encodeDatePayload(date: globalThis.Date): string {
 }
 
 function formatDateRuntime(date: globalThis.Date): string {
-  return `new Date(${format(date.getTime())})`
+  return `new globalThis.Date(${format(date.getTime())})`
 }
 /**
  * Validates that a Date is greater than the specified value (exclusive).
@@ -9799,8 +9810,7 @@ export interface fromJsonString<S extends Constraint> extends decodeTo<S, String
 }
 
 const JsonString = String.annotate({
-  expected: "a string that will be decoded as JSON",
-  contentMediaType: "application/json"
+  expected: "a string that will be decoded as JSON"
 })
 /**
  * Returns a schema that decodes a JSON string and then decodes the parsed value
@@ -16268,7 +16278,12 @@ function makeClass<
       return getClassSchema(this).rebuild(ast)
     }
     static make(input: S["~type.make.in"], options?: MakeOptions): Self {
-      return SchemaParser.make(getClassSchema(this) as any)(input ?? {}, options) as Self
+      return SchemaParser.makeClassSync(
+        SchemaAST.toType(getClassSchema(this).ast),
+        input ?? {},
+        options,
+        (fields) => makeClassTrusted(this, fields)
+      )
     }
     static makeOption(input: S["~type.make.in"], options?: MakeOptions): Option_.Option<Self> {
       return SchemaParser.makeOption(getClassSchema(this) as any)(input ?? {}, options) as any
@@ -16417,6 +16432,10 @@ function isStruct(schema: Struct.Fields | Struct<Struct.Fields>): schema is Stru
  *
  * **Gotchas**
  *
+ * To subclass a `Schema.Class`, use `Base.extend<Self>(...)`, even when only
+ * adding methods or getters. Pass `{}` for the fields when none are added.
+ * Plain `class Child extends Base` is unsupported.
+ *
  * Passing `disableChecks: true` skips filters and checks, not parsing of types
  * and structure. Wrong types and shapes are still rejected, and constructor
  * defaults still apply.
@@ -16490,6 +16509,10 @@ export const Class: {
    *
    * **Gotchas**
    *
+   * To subclass a `Schema.Class`, use `Base.extend<Self>(...)`, even when only
+   * adding methods or getters. Pass `{}` for the fields when none are added.
+   * Plain `class Child extends Base` is unsupported.
+   *
    * Passing `disableChecks: true` skips filters and checks, not parsing of types
    * and structure. Wrong types and shapes are still rejected, and constructor
    * defaults still apply.

package/src/SchemaAST.ts

@@ -2739,8 +2739,10 @@ function isIndexSignatureParameter(ast: AST): ast is IndexSignatureParameter {
  *
  * **Gotchas**
  *
- * Using `Schema.optionalKey` on the value type is not allowed for index
- * signatures (throws at construction); use `Schema.optional` instead.
+ * Using `Schema.optionalKey` or `Schema.optional` on the value type is not
+ * allowed for index signatures (throws at construction). Index signatures
+ * already allow keys to be absent; use `Schema.UndefinedOr` to allow
+ * `undefined` values.
  *
  * @see {@link Objects}
  * @see {@link PropertySignature}
@@ -2773,8 +2775,10 @@ export const IndexSignature: new(parameter: AST, type: AST) => IndexSignature =
     }
     this.parameter = parameter
     this.type = type
-    if (isOptional(type) && !containsUndefined(type)) {
-      throw new Error("Cannot use `Schema.optionalKey` with index signatures, use `Schema.optional` instead.")
+    if (isOptional(type) || (type.encoding !== undefined && isOptional(toEncoded(type)))) {
+      throw new Error(
+        "Cannot use `Schema.optionalKey` or `Schema.optional` with index signatures. Index signatures already allow keys to be absent; use `Schema.UndefinedOr` to allow `undefined` values."
+      )
     }
   }
 }
@@ -4598,16 +4602,24 @@ function parseParameter(ast: AST): {
 } {
   const literals: Array<PropertyKey> = []
   const parameters: Array<AST> = []
+  function addLiteral(literal: PropertyKey) {
+    if (!literals.includes(literal)) {
+      literals.push(literal)
+    }
+  }
   function go(ast: AST) {
     switch (ast._tag) {
       case "Literal":
-        if (Predicate.isPropertyKey(ast.literal) && !literals.includes(ast.literal)) {
-          literals.push(ast.literal)
+        if (Predicate.isPropertyKey(ast.literal)) {
+          addLiteral(ast.literal)
         }
         return
       case "UniqueSymbol":
-        if (!literals.includes(ast.symbol)) {
-          literals.push(ast.symbol)
+        addLiteral(ast.symbol)
+        return
+      case "Enum":
+        for (const [, value] of ast.enums) {
+          addLiteral(value)
         }
         return
       case "Never":
@@ -4812,18 +4824,6 @@ export const flip = memoize((ast: AST): AST => {
   return "flip" in ast ? ast.flip(flip) : "recur" in ast ? ast.recur(flip) : ast
 })
 
-/** @internal */
-export function containsUndefined(ast: AST): boolean {
-  switch (ast._tag) {
-    case "Undefined":
-      return true
-    case "Union":
-      return ast.types.some(containsUndefined)
-    default:
-      return false
-  }
-}
-
 function fromConst<const T>(
   ast: AST,
   value: T