effect 4.0.4 → 4.0.6

package/src/SchemaAST.ts

@@ -480,7 +480,7 @@ export type Encoding = readonly [Link, ...Array<Link>]
  *
  * **Details**
  *
- * Pass to `Schema.decodeUnknown`, `Schema.encode`, and related APIs to customize
+ * Pass to `Schema.decodeUnknownEffect`, `Schema.encodeEffect`, and related APIs to customize
  * error reporting, excess property handling, check execution, and product
  * concurrency. Options apply throughout the parse; schema annotations do not
  * override them.
@@ -814,7 +814,13 @@ export const Declaration: new(
     let run: ReturnType<typeof this.run>
     return (input, options) => {
       if (input === InternalParser.missing) return InternalParser.missingExit
-      return (run ??= this.run(this.typeParameters))(input, this, options)
+      // Keep this declaration's initialization errors outside its callback catch.
+      run ??= this.run(this.typeParameters)
+      try {
+        return run(input, this, options)
+      } catch (error) {
+        return Effect.die(error)
+      }
     }
   }
   private _rebuild(
@@ -2435,7 +2441,7 @@ export const Arrays: new(
         input,
         len,
         tailThreshold: Math.max(elementLen, len - tailLen),
-        output: new globalThis.Array(len),
+        output: [],
         issues: undefined,
         options
       }
@@ -2599,9 +2605,12 @@ const wrapPropertyKeyIssue = (
 
 /**
  * floating point or integer, with optional exponent
+ *
+ * The mantissa alternation keeps rejection linear: `\d*\.?\d+` retries
+ * every split of a long digit run.
  * @internal
  */
-export const FINITE_PATTERN = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?"
+export const FINITE_PATTERN = "[+-]?(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:[Ee][+-]?\\d+)?"
 
 /**
  * Returns the object keys that match the index signature parameter schema.
@@ -3101,12 +3110,14 @@ export const Objects: new(
     // Resumes at the property whose parser suspended, without replaying the
     // properties already parsed.
     const resume = (
-      state: ObjectParserState,
+      snapshot: ObjectParserState,
       index: number,
       pending: Effect.Effect<unknown, SchemaIssue.Issue, any>
     ): Effect.Effect<unknown, SchemaIssue.Issue, any> => {
       const property = properties![index]
       return Effect.flatMap(Effect.exit(pending), (exit) => {
+        // Copy the parsed prefix per execution so reruns cannot overwrite earlier results.
+        const state: ObjectParserState = { ...snapshot, out: { ...snapshot.out } }
         const terminal = stepProperty(state, property, exit)
         if (terminal) return terminal
         const done = () => InternalParser.succeed(state.out)
@@ -4278,7 +4289,7 @@ const numberToJson = new Link(
  *
  * **Details**
  *
- * The filter can be used with `Schema.filter` or attached directly to a
+ * The filter can be used with `Schema.check` or attached directly to a
  * `String` AST node through checks. The regular expression is cloned and its
  * `lastIndex` is reset before each test, so global and sticky expressions are
  * deterministic and the provided regular expression is not mutated. The
@@ -4777,7 +4788,7 @@ function flipEncoding(ast: AST, encoding: Encoding): AST {
  * **Details**
  *
  * After flipping, what was decoding becomes encoding and vice versa. This is
- * the core operation behind `Schema.encode` — encoding a value is decoding
+ * the core operation behind `Schema.encodeEffect` — encoding a value is decoding
  * with a flipped SchemaAST.
  *
  * - Memoized: same input reference → same output reference.
@@ -5110,7 +5121,7 @@ export function getConstructorDescriptor(ast: AST): ConstructorDescriptor | unde
  * **Details**
  *
  * If the node has {@link Checks}, returns annotations from the last check
- * (which is where user-supplied annotations end up after `.pipe(Schema.annotations(...))`).
+ * (which is where user-supplied annotations end up after `.pipe(Schema.annotate(...))`).
  * Otherwise returns the node's `annotations` directly.
  *
  * **Example** (Reading annotations)
@@ -5153,7 +5164,7 @@ export const resolveAt: <A>(key: string) => (ast: AST) => A | undefined = Intern
  *
  * **Details**
  *
- * The identifier is typically set by `Schema.annotations({ identifier: "..." })`
+ * The identifier is typically set by `Schema.annotate({ identifier: "..." })`
  * and is used for error messages and schema identification.
  *
  * @see {@link resolve}

package/src/SchemaGetter.ts

@@ -1159,7 +1159,8 @@ export function Boolean<E>(): Getter<boolean, E> {
  * **Details**
  *
  * - Delegates to `globalThis.BigInt`.
- * - Throws at runtime if the input cannot be converted (e.g. non-numeric string).
+ * - Fails with `SchemaIssue.InvalidValue` if the input cannot be converted
+ *   (e.g. a non-numeric string or a non-integer number).
  *
  * **Example** (Coercing to a bigint)
  *
@@ -1175,7 +1176,19 @@ export function Boolean<E>(): Getter<boolean, E> {
  * @since 4.0.0
  */
 export function BigInt<E extends string | number | bigint | boolean>(): Getter<bigint, E> {
-  return transform(globalThis.BigInt)
+  return transformEffect((input, options) => {
+    try {
+      return Effect.succeed(globalThis.BigInt(input))
+    } catch {
+      return Effect.fail(
+        new SchemaIssue.InvalidValue(
+          { expected: "a value that can be converted to a bigint" },
+          input,
+          options
+        )
+      )
+    }
+  })
 }
 
 /**
@@ -1677,7 +1690,8 @@ export function encodeBase64<E extends Uint8Array | string>(): Getter<string, E>
  *
  * **Details**
  *
- * The getter is pure and never fails.
+ * The getter is pure and never fails. The output is unpadded unless
+ * `padding` is `true`.
  *
  * **Example** (Encoding to Base64Url)
  *
@@ -1697,8 +1711,11 @@ export function encodeBase64<E extends Uint8Array | string>(): Getter<string, E>
  * @category encoding
  * @since 4.0.0
  */
-export function encodeBase64Url<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Base64Url.encode)
+export function encodeBase64Url<E extends Uint8Array | string>(options?: {
+  /** Keep the `=` padding. Defaults to `false`. */
+  readonly padding?: boolean | undefined
+}): Getter<string, E> {
+  return transform(options?.padding ? Base64Url.encodePadded : Base64Url.encode)
 }
 
 /**

package/src/SchemaIssue.ts

@@ -720,8 +720,8 @@ export const InvalidType: new(
  *
  * **When to use**
  *
- * Use when you need to detect constraint violations from `Schema.filter`,
- * `Schema.minLength`, `Schema.greaterThan`, or similar checks.
+ * Use when you need to detect constraint violations from `Schema.check` with
+ * `Schema.isMinLength`, `Schema.isGreaterThan`, or similar checks.
  *
  * **Details**
  *
@@ -1242,8 +1242,8 @@ export type CheckHook = (issue: Filter) => string | undefined
  *
  * **Details**
  *
- * - Looks for a `message` annotation on the inner issue first, then on the
- *   filter itself.
+ * - Looks for a `message` annotation on the filter first, then on the inner
+ *   issue.
  * - Returns `undefined` when no annotation is found, causing the formatter to
  *   fall back to `"Expected <filter>"` or, when the filter reports input,
  *   `"Expected <filter>, got <input>"`.
@@ -1255,7 +1255,7 @@ export type CheckHook = (issue: Filter) => string | undefined
  * @category formatting
  * @since 4.0.0
  */
-export const defaultCheckHook: CheckHook = (issue): string | undefined => findMessage(issue.issue) ?? findMessage(issue)
+export const defaultCheckHook: CheckHook = (issue): string | undefined => findMessage(issue) ?? findMessage(issue.issue)
 
 /**
  * Creates a {@link Formatter} that produces a `StandardSchemaV1.FailureResult`.
@@ -1329,46 +1329,48 @@ function getExpectedMessage(expected: string, issue: Issue): string {
   return input === undefined ? `Expected ${expected}` : `Expected ${expected}, got ${input}`
 }
 
+function getFilterMessage(issue: Filter, checkHook: CheckHook): string | undefined {
+  const message = checkHook(issue)
+  if (message !== undefined || issue.issue._tag !== "InvalidValue") return message
+  const expected = findExpected(issue.issue)
+  return expected === undefined
+    ? getExpectedMessage(formatCheck(issue.filter), issue)
+    : getExpectedMessage(expected, issue.issue)
+}
+
 function toDefaultIssues(
   issue: Issue,
   path: ReadonlyArray<PropertyKey>,
   leafHook: LeafHook,
-  checkHook: CheckHook
+  checkHook: CheckHook,
+  messageOverride?: string
 ): Array<DefaultIssue> {
   switch (issue._tag) {
-    case "Filter": {
-      const message = checkHook(issue)
-      if (message !== undefined) {
-        return [{ path, message }]
-      }
-      if (issue.issue._tag !== "InvalidValue") {
-        return toDefaultIssues(issue.issue, path, leafHook, checkHook)
-      }
-      const expected = findExpected(issue.issue)
-      return [{
+    case "Filter":
+      return toDefaultIssues(
+        issue.issue,
         path,
-        message: expected === undefined
-          ? getExpectedMessage(formatCheck(issue.filter), issue)
-          : getExpectedMessage(expected, issue.issue)
-      }]
-    }
+        leafHook,
+        checkHook,
+        messageOverride ?? getFilterMessage(issue, checkHook)
+      )
     case "Encoding":
-      return toDefaultIssues(issue.issue, path, leafHook, checkHook)
+      return toDefaultIssues(issue.issue, path, leafHook, checkHook, messageOverride)
     case "Pointer":
-      return toDefaultIssues(issue.issue, [...path, ...issue.path], leafHook, checkHook)
+      return toDefaultIssues(issue.issue, [...path, ...issue.path], leafHook, checkHook, messageOverride)
     case "Composite":
-      return issue.issues.flatMap((issue) => toDefaultIssues(issue, path, leafHook, checkHook))
     case "AnyOf": {
-      if (issue.issues.length === 0) {
-        return [{
-          path,
-          message: findMessage(issue) ?? getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue)
-        }]
+      if (issue._tag === "Composite" || issue.issues.length > 0) {
+        return issue.issues.flatMap((issue) => toDefaultIssues(issue, path, leafHook, checkHook, messageOverride))
       }
-      return issue.issues.flatMap((issue) => toDefaultIssues(issue, path, leafHook, checkHook))
+      return [{
+        path,
+        message: messageOverride ?? findMessage(issue) ??
+          getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue)
+      }]
     }
     default:
-      return [{ path, message: leafHook(issue) }]
+      return [{ path, message: messageOverride ?? leafHook(issue) }]
   }
 }
 
@@ -1431,45 +1433,34 @@ export function makeFormatterDefault(): Formatter<string> {
 /** @internal */
 export const defaultFormatter = makeFormatterDefault()
 
-function formatIssue(issue: Issue, path: string): string {
+function formatIssue(issue: Issue, path: string, messageOverride?: string): string {
   let message: string
   switch (issue._tag) {
-    case "Filter": {
-      const annotated = defaultCheckHook(issue)
-      if (annotated !== undefined) {
-        message = annotated
-      } else {
-        if (issue.issue._tag !== "InvalidValue") {
-          return formatIssue(issue.issue, path)
-        }
-        const expected = findExpected(issue.issue)
-        message = expected === undefined
-          ? getExpectedMessage(formatCheck(issue.filter), issue)
-          : getExpectedMessage(expected, issue.issue)
-      }
-      break
-    }
+    case "Filter":
+      return formatIssue(issue.issue, path, messageOverride ?? getFilterMessage(issue, defaultCheckHook))
     case "Encoding":
-      return formatIssue(issue.issue, path)
+      return formatIssue(issue.issue, path, messageOverride)
     case "Pointer":
-      return formatIssue(issue.issue, path + formatPath(issue.path))
+      return formatIssue(issue.issue, path + formatPath(issue.path), messageOverride)
     case "Composite":
     case "AnyOf": {
       if (issue._tag === "Composite" || issue.issues.length > 0) {
-        return issue.issues.map((issue) => formatIssue(issue, path)).join("\n")
+        return issue.issues.map((issue) => formatIssue(issue, path, messageOverride)).join("\n")
       }
-      message = findMessage(issue) ?? getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue)
+      message = messageOverride ?? findMessage(issue) ??
+        getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue)
       break
     }
     default:
-      message = defaultLeafHook(issue)
+      message = messageOverride ?? defaultLeafHook(issue)
       break
   }
   return path ? `${message}\n  at ${path}` : message
 }
 
 function findMessage(issue: Issue): string | undefined {
-  if (issue._tag === "Pointer") return
+  // A Composite's ast describes the whole schema, not the failures it groups.
+  if (issue._tag === "Pointer" || issue._tag === "Composite") return
   if (issue._tag === "Encoding") return findMessage(issue.issue)
   const annotations = issue._tag === "Filter"
     ? issue.filter.annotations

package/src/SchemaRepresentation.ts

@@ -1944,6 +1944,32 @@ export const BigDecimalReviver: DeclarationReviver<null> = makeFixedDeclarationR
   Schema.BigDecimal
 )
 
+/**
+ * Reviver for persisted {@link Schema.SemVer} declarations.
+ *
+ * @see {@link Schema.SemVer} for the corresponding schema
+ * @stability unstable
+ * @category schemas
+ * @since 4.0.6
+ */
+export const SemVerReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/SemVer",
+  Schema.SemVer
+)
+
+/**
+ * Reviver for persisted {@link Schema.SemVerRange} declarations.
+ *
+ * @see {@link Schema.SemVerRange} for the corresponding schema
+ * @stability unstable
+ * @category schemas
+ * @since 4.0.6
+ */
+export const SemVerRangeReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/SemVerRange",
+  Schema.SemVerRange
+)
+
 /**
  * Reviver for persisted `File` declarations.
  *
@@ -2387,7 +2413,8 @@ const jsonSchemaRevivers: ReadonlyArray<AnyReviver> = [
  *
  * **When to use**
  *
- * Use when you need to configure pattern handling or transform each JSON Schema node before translation.
+ * Use when you need to configure pattern handling, preserve custom annotations, or transform each JSON Schema node
+ * before translation.
  *
  * **Details**
  *
@@ -2422,6 +2449,42 @@ export interface FromJsonSchemaOptions {
    * @default "error"
    */
   readonly patterns?: "error" | "ignore" | "apply" | undefined
+  /**
+   * Selects additional JSON Schema keys to preserve as Effect schema annotations.
+   *
+   * **Details**
+   *
+   * Standard annotations such as `title` and `description` are imported independently of this predicate.
+   * Other keys are ignored by default. Selected values must be JSON-compatible and are kept as opaque metadata.
+   * Selection runs after `onEnter`. JSON Schema structural and validation keywords, Effect's reserved annotation
+   * keys, and keys starting with `~` are excluded before calling the predicate. Exceptions from the predicate
+   * pass through unchanged.
+   *
+   * **Gotchas**
+   *
+   * Import normalizes the schema. Selected annotations stay on surviving values when checks simplify, and
+   * annotations from eliminated alternatives or unreachable children are discarded. When schemas merge,
+   * later annotations overwrite earlier values for the same key, following the importer's merge order.
+   * Retaining an annotation does not enforce its semantics or preserve the original JSON Schema structure.
+   *
+   * **Example** (Preserving custom metadata on import and export)
+   *
+   * ```ts import.meta.vitest
+   * import { JsonSchema, Schema, SchemaRepresentation } from "effect"
+   *
+   * const document = JsonSchema.fromSchemaDraft2020_12({
+   *   type: "string",
+   *   "x-sensitive": true
+   * })
+   * const options = { includeAnnotationKey: (key: string) => key.startsWith("x-") }
+   * const schema = SchemaRepresentation.fromJsonSchemaDocument(document, options)
+   *
+   * Schema.toJsonSchemaDocument(schema, options).schema // => { type: "string", "x-sensitive": true }
+   * ```
+   *
+   * @see Schema.ToJsonSchemaOptions
+   */
+  readonly includeAnnotationKey?: ((key: string) => boolean) | undefined
 }
 
 /**

package/src/SchemaTransformation.ts

@@ -1877,7 +1877,7 @@ export const stringFromHexString: Transformation<string, string> = new Transform
  * **When to use**
  *
  * Use when you need a schema transformation to store structured data in URL
- * query parameters or fragments, such as composing with `Schema.parseJson` to
+ * query parameters or fragments, such as composing with `Schema.fromJsonString` to
  * round-trip JSON through a URL.
  *
  * **Details**

package/src/Scope.ts

@@ -159,8 +159,13 @@ export declare namespace State {
     finalizers: Map<{}, (exit: Exit<any, any>) => Effect<void>> | undefined
   }
   /**
-   * Represents a closed scope state where finalizers have been executed
-   * and the scope is no longer accepting new resources.
+   * Represents a closed scope state where the scope is no longer accepting
+   * new resources.
+   *
+   * **Details**
+   *
+   * The scope enters this state when closing starts, so its finalizers may
+   * still be running.
    *
    * **Example** (Inspecting a closed scope state)
    *
@@ -557,6 +562,11 @@ export const forkUnsafe: (scope: Scope, finalizerStrategy?: "sequential" | "para
  * By default, finalizers run uninterruptibly, so interrupting the closing fiber
  * waits for them to finish; a finalizer can explicitly restore interruptibility.
  *
+ * **Gotchas**
+ *
+ * Closing a scope that is already closed returns immediately, even when the
+ * finalizers of an earlier close are still running.
+ *
  * **Example** (Running scope finalizers)
  *
  * ```ts import.meta.vitest

package/src/ScopedCache.ts

@@ -7,6 +7,8 @@
  * remaining entries when the cache is closed. Lookups for the same missing key
  * share one in-progress effect, and entries can expire, be refreshed, be
  * invalidated, or be evicted by capacity limits.
+ * Expiry cleanup is lazy: an expired entry is removed on access to that key or
+ * a `keys`/`values`/`entries` scan, not by a background timer.
  *
  * @stability stable
  * @since 4.0.0
@@ -39,14 +41,15 @@ const TypeId = "~effect/ScopedCache"
  * **When to use**
  *
  * Use to cache values that acquire scoped resources and must release those
- * resources when entries expire, are evicted, or are invalidated.
+ * resources when entries are removed or the owning scope closes.
  *
  * **Details**
  *
  * Concurrent requests for the same key share the same in-flight lookup.
  * Entries can expire based on the lookup exit, are evicted when capacity is
- * exceeded, and release their entry scopes when invalidated, evicted, expired,
- * or when the cache's owning scope closes.
+ * exceeded, and release their entry scopes when invalidated, evicted, or when
+ * the cache's owning scope closes. Expired entries are cleaned up lazily on
+ * access to that key or a `keys`/`values`/`entries` scan, never in the background.
  *
  * @see {@link make} for creating a scoped cache with a fixed time-to-live
  * @see {@link makeWith} for creating a scoped cache with dynamic time-to-live
@@ -127,8 +130,9 @@ export interface Entry<A, E> {
  * **Details**
  *
  * The cache must be constructed in a `Scope`. Each lookup runs in its own entry
- * scope, and that scope is closed when the entry expires, is invalidated, is
- * evicted by capacity, or when the cache's owning scope closes.
+ * scope, and that scope is closed when the entry is invalidated, is evicted by
+ * capacity, or when the cache's owning scope closes. Expired entries are cleaned
+ * up on access to that key or a `keys`/`values`/`entries` scan, not in the background.
  * `requireServicesAt` controls whether lookup services are captured at
  * construction time or required when lookup operations run.
  *
@@ -192,8 +196,9 @@ export const makeWith = <
  *
  * This is the constant-TTL variant of `makeWith`: values are acquired by the
  * lookup effect in per-entry scopes, capacity can evict older entries, and
- * entry scopes are closed when entries expire, are invalidated, are evicted, or
- * when the cache's owning scope closes.
+ * entry scopes are closed when entries are invalidated, are evicted, or when
+ * the cache's owning scope closes. Expiry cleanup is lazy: expired entries close
+ * on access to that key or a `keys`/`values`/`entries` scan, not in the background.
  *
  * @see {@link makeWith} for computing time-to-live from each lookup result and key
  *
@@ -330,55 +335,7 @@ export const get: {
           return awaitEntry(self, key, oentry.value, restore)
         }
         const scope = Scope.makeUnsafe()
-        const deferred = Deferred.makeUnsafe</**
-         * Gets the value for a key, running the cache lookup when no unexpired entry is
-         * present.
-         *
-         * **When to use**
-         *
-         * Use to retrieve a scoped cached value by key when a missing or expired entry
-         * should run the cache lookup and share the in-flight lookup with concurrent
-         * callers.
-         *
-         * **Details**
-         *
-         * Concurrent `get` calls for the same key share the same in-flight lookup.
-         * Successful and failed lookup exits are cached according to the configured
-         * TTL. If the cache is closed, the effect is interrupted.
-         *
-         * @see {@link getOption} for reading only when an unexpired entry is already cached
-         * @see {@link getSuccess} for inspecting an already-completed successful entry
-         * @see {@link refresh} for forcing a new lookup
-         *
-         * @stability stable
-         * @category combinators
-         * @since 4.0.0
-         */
-        A, /**
-         * Gets the value for a key, running the cache lookup when no unexpired entry is
-         * present.
-         *
-         * **When to use**
-         *
-         * Use to retrieve a scoped cached value by key when a missing or expired entry
-         * should run the cache lookup and share the in-flight lookup with concurrent
-         * callers.
-         *
-         * **Details**
-         *
-         * Concurrent `get` calls for the same key share the same in-flight lookup.
-         * Successful and failed lookup exits are cached according to the configured
-         * TTL. If the cache is closed, the effect is interrupted.
-         *
-         * @see {@link getOption} for reading only when an unexpired entry is already cached
-         * @see {@link getSuccess} for inspecting an already-completed successful entry
-         * @see {@link refresh} for forcing a new lookup
-         *
-         * @stability stable
-         * @category combinators
-         * @since 4.0.0
-         */
-        E>()
+        const deferred = Deferred.makeUnsafe<A, E>()
         const entry: Entry<A, E> = {
           expiresAt: undefined,
           deferred,
@@ -748,49 +705,7 @@ export const set: {
         const oentry = MutableHashMap.get(self.state.map, key)
         const state = self.state
         const exit = core.exitSucceed(value)
-        const deferred = Deferred.makeUnsafe</**
-         * Sets a successful value for a key without running the lookup function.
-         *
-         * **When to use**
-         *
-         * Use to seed or overwrite a scoped cache entry with an already available
-         * successful value.
-         *
-         * **Details**
-         *
-         * This replaces and closes any existing entry scope for the key, applies the
-         * cache's TTL using a successful exit for the value, and may evict older
-         * entries if the cache capacity is exceeded.
-         *
-         * @see {@link get} for reading or computing a cached value
-         * @see {@link refresh} for replacing an entry by running the lookup function
-         *
-         * @stability stable
-         * @category combinators
-         * @since 4.0.0
-         */
-        A, /**
-         * Sets a successful value for a key without running the lookup function.
-         *
-         * **When to use**
-         *
-         * Use to seed or overwrite a scoped cache entry with an already available
-         * successful value.
-         *
-         * **Details**
-         *
-         * This replaces and closes any existing entry scope for the key, applies the
-         * cache's TTL using a successful exit for the value, and may evict older
-         * entries if the cache capacity is exceeded.
-         *
-         * @see {@link get} for reading or computing a cached value
-         * @see {@link refresh} for replacing an entry by running the lookup function
-         *
-         * @stability stable
-         * @category combinators
-         * @since 4.0.0
-         */
-        E>()
+        const deferred = Deferred.makeUnsafe<A, E>()
         Deferred.doneUnsafe(deferred, exit)
         const ttl = self.timeToLive(exit, key)
         MutableHashMap.set(state.map, key, {
@@ -1149,47 +1064,7 @@ export const refresh: {
       if (!MutableHashMap.has(self.state.map, key)) return yield* restore(get(self, key))
       const fiber = Fiber.getCurrent()!
       const scope = Scope.makeUnsafe()
-      const deferred = Deferred.makeUnsafe</**
-       * Forces a refresh of the value associated with the specified key in the cache.
-       *
-       * **When to use**
-       *
-       * Use to recompute a scoped cache entry immediately, even when an unexpired
-       * value is already cached.
-       *
-       * **Details**
-       *
-       * It will always invoke the lookup function to construct a new value,
-       * overwriting any existing value for that key.
-       *
-       * @see {@link get} for reusing an unexpired entry before running the lookup
-       * @see {@link invalidate} for removing an entry without recomputing it
-       *
-       * @stability stable
-       * @category combinators
-       * @since 4.0.0
-       */
-      A, /**
-       * Forces a refresh of the value associated with the specified key in the cache.
-       *
-       * **When to use**
-       *
-       * Use to recompute a scoped cache entry immediately, even when an unexpired
-       * value is already cached.
-       *
-       * **Details**
-       *
-       * It will always invoke the lookup function to construct a new value,
-       * overwriting any existing value for that key.
-       *
-       * @see {@link get} for reusing an unexpired entry before running the lookup
-       * @see {@link invalidate} for removing an entry without recomputing it
-       *
-       * @stability stable
-       * @category combinators
-       * @since 4.0.0
-       */
-      E>()
+      const deferred = Deferred.makeUnsafe<A, E>()
       const exit = yield* effect.exit(effect.suspend(() => restore(Scope.provide(self.lookup(key), scope))))
       Deferred.doneUnsafe(deferred, exit)
       if (effect.exitHasInterrupts(exit)) {
@@ -1252,11 +1127,11 @@ const invalidateAllImpl = <Key, A, E>(
   // Detach the batch before finalizers can reenter the cache.
   const entries = Array.from(MutableHashMap.values(map))
   MutableHashMap.clear(map)
-  const fibers = Arr.empty<Fiber.Fiber<unknown, unknown>>()
+  const fibers = Arr.empty<Fiber.Fiber<void>>()
   for (const entry of entries) {
     fibers.push(effect.forkUnsafe(parent as any, Scope.close(entry.scope, effect.exitVoid), true, true))
   }
-  return effect.fiberAwaitAll(fibers)
+  return effect.flatMap(effect.fiberAwaitAll(fibers), Exit.asVoidAll)
 }
 
 /**