effect 4.0.0-beta.2 → 4.0.0-beta.21

package/src/internal/hashMap.ts

@@ -3,6 +3,7 @@
  */
 
 import * as Equal_ from "../Equal.ts"
+import type * as Filter from "../Filter.ts"
 import { format } from "../Formatter.ts"
 import { dual, pipe } from "../Function.ts"
 import * as Hash from "../Hash.ts"
@@ -12,6 +13,7 @@ import * as Option from "../Option.ts"
 import type { Pipeable } from "../Pipeable.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import { hasProperty } from "../Predicate.ts"
+import * as Result from "../Result.ts"
 import type { NoInfer } from "../Types.ts"
 
 /** @internal */
@@ -83,7 +85,7 @@ function mergeLeaves<K, V>(
   }
 
   const bitmap = bit1 | bit2
-  const children: Array<Node<K, V>> = bit1 < bit2
+  const children: Array<Node<K, V>> = (bit1 >>> 0) < (bit2 >>> 0)
     ? [node1, node2]
     : [node2, node1]
 
@@ -248,7 +250,7 @@ class LeafNode<K, V> extends Node<K, V> {
     }
 
     const bitmap = newBit | existingBit
-    const nodes: Array<Node<K, V>> = newBit < existingBit
+    const nodes: Array<Node<K, V>> = (newBit >>> 0) < (existingBit >>> 0)
       ? [new LeafNode(edit, hash, key, value), this]
       : [this, new LeafNode(edit, hash, key, value)]
 
@@ -1255,14 +1257,14 @@ export const compact = <K, A>(self: HashMap<K, Option.Option<A>>): HashMap<K, A>
 
 /** @internal */
 export const filterMap = dual<
-  <A, K, B>(f: (value: A, key: K) => Option.Option<B>) => (self: HashMap<K, A>) => HashMap<K, B>,
-  <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option.Option<B>) => HashMap<K, B>
->(2, <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option.Option<B>): HashMap<K, B> => {
+  <A, K, B, X>(f: Filter.Filter<A, B, X, [key: K]>) => (self: HashMap<K, A>) => HashMap<K, B>,
+  <K, A, B, X>(self: HashMap<K, A>, f: Filter.Filter<A, B, X, [key: K]>) => HashMap<K, B>
+>(2, <K, A, B, X>(self: HashMap<K, A>, f: Filter.Filter<A, B, X, [key: K]>): HashMap<K, B> => {
   let result = empty<K, B>()
   for (const [key, value] of self) {
     const mapped = f(value, key)
-    if (Option.isSome(mapped)) {
-      result = set(result, key, mapped.value)
+    if (Result.isSuccess(mapped)) {
+      result = set(result, key, mapped.success)
     }
   }
   return result

package/src/internal/random.ts

@@ -0,0 +1,20 @@
+import * as ServiceMap from "../ServiceMap.ts"
+
+/** @internal */
+export interface Random {
+  nextIntUnsafe(): number
+  nextDoubleUnsafe(): number
+}
+
+/** @internal */
+export const Random: ServiceMap.Reference<Random> = ServiceMap.Reference<Random>("effect/Random", {
+  defaultValue: () => ({
+    nextIntUnsafe() {
+      return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +
+        Number.MIN_SAFE_INTEGER
+    },
+    nextDoubleUnsafe() {
+      return Math.random()
+    }
+  })
+})

package/src/internal/rcRef.ts

@@ -6,6 +6,7 @@ import { identity } from "../Function.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import type * as RcRef from "../RcRef.ts"
 import * as Scope from "../Scope.ts"
+import * as Semaphore from "../Semaphore.ts"
 import * as ServiceMap from "../ServiceMap.ts"
 
 const TypeId = "~effect/RcRef"
@@ -47,7 +48,7 @@ class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
   }
 
   state: State<A> = stateEmpty
-  readonly semaphore = Effect.makeSemaphoreUnsafe(1)
+  readonly semaphore = Semaphore.makeUnsafe(1)
   readonly acquire: Effect.Effect<A, E>
   readonly services: ServiceMap.ServiceMap<never>
   readonly scope: Scope.Scope
@@ -69,7 +70,7 @@ class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
 /** @internal */
 export const make = <A, E, R>(options: {
   readonly acquire: Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.Input | undefined
 }) =>
   Effect.withFiber<RcRef.RcRef<A, E>, never, R | Scope.Scope>((fiber) => {
     const services = fiber.services as ServiceMap.ServiceMap<R | Scope.Scope>
@@ -78,7 +79,7 @@ export const make = <A, E, R>(options: {
       options.acquire as Effect.Effect<A, E>,
       services,
       scope,
-      options.idleTimeToLive ? Duration.fromDurationInputUnsafe(options.idleTimeToLive) : undefined
+      options.idleTimeToLive ? Duration.fromInputUnsafe(options.idleTimeToLive) : undefined
     )
     return Effect.as(
       Scope.addFinalizerExit(scope, () => {

package/src/internal/request.ts

@@ -159,7 +159,7 @@ const addEntry = <A extends Request.Any>(
       batch = newBatch
     }
     batchMap.set(key, batch)
-    batch.fiber = effect.runFork(batch.delayEffect, { scheduler: fiber.currentScheduler })
+    batch.fiber = effect.runForkWith(fiber.services)(batch.delayEffect, { scheduler: fiber.currentScheduler })
   }
 
   batch.entrySet.add(entry)
@@ -167,7 +167,7 @@ const addEntry = <A extends Request.Any>(
   if (batch.resolver.collectWhile(batch.entries)) return entry
 
   batch.fiber!.interruptUnsafe(fiber.id)
-  batch.fiber = effect.runFork(runBatch(batch), { scheduler: fiber.currentScheduler })
+  batch.fiber = effect.runForkWith(fiber.services)(runBatch(batch), { scheduler: fiber.currentScheduler })
   return entry
 }
 

package/src/internal/schema/annotations.ts

@@ -26,6 +26,8 @@ export const resolveBrands = resolveAt<ReadonlyArray<string>>("brands")
 
 /** @internal */
 export const getExpected = memoize((ast: AST.AST): string => {
+  const identifier = resolveIdentifier(ast)
+  if (typeof identifier === "string") return identifier
   return ast.getExpected(getExpected)
 })
 

package/src/internal/schema/schema.ts

@@ -31,5 +31,6 @@ export function make<S extends Schema.Top>(ast: S["ast"], options?: object): S {
   self.ast = ast
   self.rebuild = (ast: AST.AST) => make(ast, options)
   self.makeUnsafe = Parser.makeUnsafe(self)
+  self.makeOption = Parser.makeOption(self)
   return self
 }

package/src/internal/trie.ts

@@ -1,12 +1,14 @@
 import * as Equal from "../Equal.ts"
+import type * as Filter from "../Filter.ts"
 import { format } from "../Formatter.ts"
-import { dual, identity, pipe } from "../Function.ts"
+import { dual, pipe } from "../Function.ts"
 import * as Hash from "../Hash.ts"
 import { NodeInspectSymbol, toJson } from "../Inspectable.ts"
 import * as Option from "../Option.ts"
 import type * as Ordering from "../Ordering.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import { hasProperty } from "../Predicate.ts"
+import * as Result from "../Result.ts"
 import type * as TR from "../Trie.ts"
 import type { NoInfer } from "../Types.ts"
 
@@ -309,22 +311,27 @@ export const filter: {
 
 /** @internal */
 export const filterMap = dual<
-  <A, B>(
-    f: (value: A, key: string) => Option.Option<B>
+  <A, B, X>(
+    f: Filter.Filter<A, B, X, [key: string]>
   ) => (self: TR.Trie<A>) => TR.Trie<B>,
-  <A, B>(self: TR.Trie<A>, f: (value: A, key: string) => Option.Option<B>) => TR.Trie<B>
->(2, (self, f) =>
+  <A, B, X>(self: TR.Trie<A>, f: Filter.Filter<A, B, X, [key: string]>) => TR.Trie<B>
+>(2, <A, B, X>(self: TR.Trie<A>, f: Filter.Filter<A, B, X, [key: string]>): TR.Trie<B> =>
   reduce(
     self,
-    empty(),
+    empty<B>(),
     (trie, value, key) => {
-      const option = f(value, key)
-      return Option.isSome(option) ? insert(trie, key, option.value) : trie
+      const result = f(value, key)
+      return Result.isSuccess(result) ? insert(trie, key, result.success) : trie
     }
   ))
 
 /** @internal */
-export const compact = <A>(self: TR.Trie<Option.Option<A>>) => filterMap(self, identity)
+export const compact = <A>(self: TR.Trie<Option.Option<A>>) =>
+  reduce(
+    self,
+    empty<A>(),
+    (trie, option, key) => Option.isSome(option) ? insert(trie, key, option.value) : trie
+  )
 
 /** @internal */
 export const forEach = dual<

package/src/testing/TestClock.ts

@@ -8,8 +8,10 @@ import * as Duration from "../Duration.ts"
 import * as Effect from "../Effect.ts"
 import * as Fiber from "../Fiber.ts"
 import { flow } from "../Function.ts"
+import * as Latch from "../Latch.ts"
 import * as Layer from "../Layer.ts"
 import * as Order from "../Order.ts"
+import * as Semaphore from "../Semaphore.ts"
 
 /**
  * A `TestClock` simplifies deterministically and efficiently testing effects
@@ -79,7 +81,7 @@ export interface TestClock extends Clock.Clock {
    * that were scheduled to occur on or before the new time will be run in
    * order.
    */
-  adjust(duration: Duration.DurationInput): Effect.Effect<void>
+  adjust(duration: Duration.Input): Effect.Effect<void>
   /**
    * Sets the current clock time to the specified `timestamp`. Any effects that
    * were scheduled to occur on or before the new time will be run in order.
@@ -139,7 +141,7 @@ export declare namespace TestClock {
      * The amount of time to wait before displaying a warning message when a
      * test is using time but is not advancing the `TestClock`.
      */
-    readonly warningDelay?: Duration.DurationInput
+    readonly warningDelay?: Duration.Input
   }
 
   /**
@@ -155,7 +157,7 @@ export declare namespace TestClock {
    *   const timestamp = testClock.currentTimeMillisUnsafe()
    *   console.log(timestamp) // Current test time
    *
-   *   // Internal state structure: { timestamp: number, sleeps: Array<[number, Effect.Latch]> }
+   *   // Internal state structure: { timestamp: number, sleeps: Array<[number, Latch.Latch]> }
    * })
    * ```
    *
@@ -164,7 +166,7 @@ export declare namespace TestClock {
    */
   export interface State {
     readonly timestamp: number
-    readonly sleeps: ReadonlyArray<[number, Effect.Latch]>
+    readonly sleeps: ReadonlyArray<[number, Latch.Latch]>
   }
 }
 
@@ -220,10 +222,10 @@ export const make = Effect.fnUntraced(function*(
   const sleeps: Array<{
     readonly sequence: number
     readonly timestamp: number
-    readonly latch: Effect.Latch
+    readonly latch: Latch.Latch
   }> = []
   const liveClock = yield* Clock.clockWith(Effect.succeed)
-  const warningSemaphore = yield* Effect.makeSemaphore(1)
+  const warningSemaphore = yield* Semaphore.make(1)
 
   let currentTimestamp: number = new Date(0).getTime()
   let warningState: WarningState = WarningState.Start()
@@ -292,7 +294,7 @@ export const make = Effect.fnUntraced(function*(
     const millis = Duration.toMillis(duration)
     const end = currentTimestamp + millis
     if (end <= currentTimestamp) return
-    const latch = Effect.makeLatchUnsafe()
+    const latch = Latch.makeUnsafe()
     sleeps.push({
       sequence: sequence++,
       timestamp: end,
@@ -303,7 +305,7 @@ export const make = Effect.fnUntraced(function*(
     yield* latch.await
   })
 
-  const runSemaphore = yield* Effect.makeSemaphore(1)
+  const runSemaphore = yield* Semaphore.make(1)
   const run = Effect.fnUntraced(function*(step: (currentTimestamp: number) => number) {
     yield* Fiber.await(yield* Effect.forkScoped(Effect.yieldNow))
     const endTimestamp = step(currentTimestamp)
@@ -317,8 +319,8 @@ export const make = Effect.fnUntraced(function*(
     currentTimestamp = endTimestamp
   }, runSemaphore.withPermits(1))
 
-  function adjust(duration: Duration.DurationInput) {
-    const millis = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+  function adjust(duration: Duration.Input) {
+    const millis = Duration.toMillis(Duration.fromInputUnsafe(duration))
     return warningDone.pipe(Effect.andThen(run((timestamp) => timestamp + millis)))
   }
 
@@ -429,7 +431,7 @@ export const testClockWith = <A, E, R>(
  * @since 2.0.0
  * @category utils
  */
-export const adjust = (duration: Duration.DurationInput): Effect.Effect<void> =>
+export const adjust = (duration: Duration.Input): Effect.Effect<void> =>
   testClockWith((testClock) => testClock.adjust(duration))
 
 /**

package/src/testing/TestSchema.ts

@@ -156,16 +156,16 @@ export class Decoding<S extends Schema.Top> {
   /**
    * Asserts that decoding succeeds with the expected value.
    */
-  async succeed<S extends Schema.Codec<unknown, unknown, never, unknown>>(
+  async succeed<S extends Schema.Decoder<unknown, never>>(
     this: Decoding<S>,
     input: unknown
   ): Promise<void>
-  async succeed<S extends Schema.Codec<unknown, unknown, never, unknown>>(
+  async succeed<S extends Schema.Decoder<unknown, never>>(
     this: Decoding<S>,
     input: unknown,
     expected: S["Type"]
   ): Promise<void>
-  async succeed<S extends Schema.Codec<unknown, unknown, never, unknown>>(
+  async succeed<S extends Schema.Decoder<unknown, never>>(
     this: Decoding<S>,
     input: unknown,
     expected?: S["Type"]
@@ -182,7 +182,7 @@ export class Decoding<S extends Schema.Top> {
   /**
    * Asserts that decoding fails with the expected error message.
    */
-  async fail<S extends Schema.Codec<unknown, unknown, never, unknown>>(
+  async fail<S extends Schema.Decoder<unknown, never>>(
     this: Decoding<S>,
     input: unknown,
     message: string
@@ -200,7 +200,7 @@ export class Decoding<S extends Schema.Top> {
    * decoding context.
    */
   provide<Id, Service>(
-    service: ServiceMap.Service<Id, Service>,
+    service: ServiceMap.Key<Id, Service>,
     implementation: Service
   ): Decoding<Schema.middlewareDecoding<S, Exclude<S["DecodingServices"], Id>>> {
     return new Decoding(
@@ -232,16 +232,16 @@ class Encoding<S extends Schema.Top> {
   /**
    * Asserts that encoding succeeds with the expected value.
    */
-  async succeed<S extends Schema.Codec<unknown, unknown, unknown, never>>(
+  async succeed<S extends Schema.Encoder<unknown, never>>(
     this: Encoding<S>,
     input: unknown
   ): Promise<void>
-  async succeed<S extends Schema.Codec<unknown, unknown, unknown, never>>(
+  async succeed<S extends Schema.Encoder<unknown, never>>(
     this: Encoding<S>,
     input: unknown,
     expected: S["Encoded"]
   ): Promise<void>
-  async succeed<S extends Schema.Codec<unknown, unknown, unknown, never>>(
+  async succeed<S extends Schema.Encoder<unknown, never>>(
     this: Encoding<S>,
     input: unknown,
     expected?: S["Encoded"]
@@ -258,7 +258,7 @@ class Encoding<S extends Schema.Top> {
   /**
    * Asserts that encoding fails with the expected error message.
    */
-  async fail<S extends Schema.Codec<unknown, unknown, unknown, never>>(
+  async fail<S extends Schema.Encoder<unknown, never>>(
     this: Encoding<S>,
     input: unknown,
     message: string
@@ -276,7 +276,7 @@ class Encoding<S extends Schema.Top> {
    * encoding context.
    */
   provide<Id, Service>(
-    service: ServiceMap.Service<Id, Service>,
+    service: ServiceMap.Key<Id, Service>,
     implementation: Service
   ): Encoding<Schema.middlewareEncoding<S, Exclude<S["EncodingServices"], Id>>> {
     return new Encoding(

package/src/unstable/ai/AiError.ts

@@ -89,8 +89,11 @@ import { HttpRequestDetails, HttpResponseDetails } from "./Response.ts"
 
 const ReasonTypeId = "~effect/unstable/ai/AiError/Reason" as const
 
-const constEmptyObjectOption = () => Option.some({})
-const constEmptyObject = () => ({})
+const providerMetadataWithDefaults = <Metadata extends ProviderMetadata>() =>
+  (ProviderMetadata as unknown as typeof ProviderMetadata & Schema.Schema<Metadata>).pipe(
+    Schema.withConstructorDefault(() => Option.some({} as Metadata)),
+    Schema.withDecodingDefault(() => ({} as Metadata))
+  )
 
 const redactHeaders = (headers: Record<string, string>): Record<string, string> => {
   const redacted = redact(headers) as Record<string, string | Redacted.Redacted>
@@ -247,9 +250,9 @@ export class NetworkError extends Schema.ErrorClass<NetworkError>(
  * @since 1.0.0
  * @category schemas
  */
-export const ProviderMetadata: Schema.Record$<
+export const ProviderMetadata: Schema.$Record<
   Schema.String,
-  Schema.NullOr<Schema.Codec<Schema.MutableJson, Schema.MutableJson, never, never>>
+  Schema.NullOr<Schema.Codec<Schema.MutableJson>>
 > = Schema.Record(Schema.String, Schema.NullOr(Schema.MutableJson))
 
 /**
@@ -258,6 +261,86 @@ export const ProviderMetadata: Schema.Record$<
  */
 export type ProviderMetadata = typeof ProviderMetadata.Type
 
+/**
+ * Provider-specific metadata attached to `RateLimitError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface RateLimitErrorMetadata extends ProviderMetadata {}
+
+/**
+ * Provider-specific metadata attached to `QuotaExhaustedError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface QuotaExhaustedErrorMetadata extends ProviderMetadata {}
+
+/**
+ * Provider-specific metadata attached to `AuthenticationError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface AuthenticationErrorMetadata extends ProviderMetadata {}
+
+/**
+ * Provider-specific metadata attached to `ContentPolicyError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface ContentPolicyErrorMetadata extends ProviderMetadata {}
+
+/**
+ * Provider-specific metadata attached to `InvalidRequestError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface InvalidRequestErrorMetadata extends ProviderMetadata {}
+
+/**
+ * Provider-specific metadata attached to `InternalProviderError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface InternalProviderErrorMetadata extends ProviderMetadata {}
+
+/**
+ * Provider-specific metadata attached to `InvalidOutputError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface InvalidOutputErrorMetadata extends ProviderMetadata {}
+
+/**
+ * Provider-specific metadata attached to `StructuredOutputError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface StructuredOutputErrorMetadata extends ProviderMetadata {}
+
+/**
+ * Provider-specific metadata attached to `UnsupportedSchemaError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface UnsupportedSchemaErrorMetadata extends ProviderMetadata {}
+
+/**
+ * Provider-specific metadata attached to `UnknownError`.
+ *
+ * @since 1.0.0
+ * @category provider options
+ */
+export interface UnknownErrorMetadata extends ProviderMetadata {}
+
 /**
  * Token usage information from AI operations.
  *
@@ -313,10 +396,7 @@ export class RateLimitError extends Schema.ErrorClass<RateLimitError>(
 )({
   _tag: Schema.tag("RateLimitError"),
   retryAfter: Schema.optional(Schema.Duration),
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  ),
+  metadata: providerMetadataWithDefaults<RateLimitErrorMetadata>(),
   http: Schema.optional(HttpContext)
 }) {
   /**
@@ -364,10 +444,7 @@ export class QuotaExhaustedError extends Schema.ErrorClass<QuotaExhaustedError>(
 )({
   _tag: Schema.tag("QuotaExhaustedError"),
   resetAt: Schema.optional(Schema.DateTimeUtc),
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  ),
+  metadata: providerMetadataWithDefaults<QuotaExhaustedErrorMetadata>(),
   http: Schema.optional(HttpContext)
 }) {
   /**
@@ -417,10 +494,7 @@ export class AuthenticationError extends Schema.ErrorClass<AuthenticationError>(
 )({
   _tag: Schema.tag("AuthenticationError"),
   kind: Schema.Literals(["InvalidKey", "ExpiredKey", "MissingKey", "InsufficientPermissions", "Unknown"]),
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  ),
+  metadata: providerMetadataWithDefaults<AuthenticationErrorMetadata>(),
   http: Schema.optional(HttpContext)
 }) {
   /**
@@ -475,10 +549,7 @@ export class ContentPolicyError extends Schema.ErrorClass<ContentPolicyError>(
 )({
   _tag: Schema.tag("ContentPolicyError"),
   description: Schema.String,
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  ),
+  metadata: providerMetadataWithDefaults<ContentPolicyErrorMetadata>(),
   http: Schema.optional(HttpContext)
 }) {
   /**
@@ -530,10 +601,7 @@ export class InvalidRequestError extends Schema.ErrorClass<InvalidRequestError>(
   parameter: Schema.optional(Schema.String),
   constraint: Schema.optional(Schema.String),
   description: Schema.optional(Schema.String),
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  ),
+  metadata: providerMetadataWithDefaults<InvalidRequestErrorMetadata>(),
   http: Schema.optional(HttpContext)
 }) {
   /**
@@ -585,10 +653,7 @@ export class InternalProviderError extends Schema.ErrorClass<InternalProviderErr
 )({
   _tag: Schema.tag("InternalProviderError"),
   description: Schema.String,
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  ),
+  metadata: providerMetadataWithDefaults<InternalProviderErrorMetadata>(),
   http: Schema.optional(HttpContext)
 }) {
   /**
@@ -636,10 +701,7 @@ export class InvalidOutputError extends Schema.ErrorClass<InvalidOutputError>(
 )({
   _tag: Schema.tag("InvalidOutputError"),
   description: Schema.String,
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  ),
+  metadata: providerMetadataWithDefaults<InvalidOutputErrorMetadata>(),
   usage: Schema.optional(UsageInfo)
 }) {
   /**
@@ -710,10 +772,7 @@ export class StructuredOutputError extends Schema.ErrorClass<StructuredOutputErr
 )({
   _tag: Schema.tag("StructuredOutputError"),
   description: Schema.String,
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  ),
+  metadata: providerMetadataWithDefaults<StructuredOutputErrorMetadata>(),
   usage: Schema.optional(UsageInfo)
 }) {
   /**
@@ -785,10 +844,7 @@ export class UnsupportedSchemaError extends Schema.ErrorClass<UnsupportedSchemaE
 )({
   _tag: Schema.tag("UnsupportedSchemaError"),
   description: Schema.String,
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  )
+  metadata: providerMetadataWithDefaults<UnsupportedSchemaErrorMetadata>()
 }) {
   /**
    * @since 1.0.0
@@ -835,10 +891,7 @@ export class UnknownError extends Schema.ErrorClass<UnknownError>(
 )({
   _tag: Schema.tag("UnknownError"),
   description: Schema.optional(Schema.String),
-  metadata: ProviderMetadata.pipe(
-    Schema.withConstructorDefault(constEmptyObjectOption),
-    Schema.withDecodingDefault(constEmptyObject)
-  ),
+  metadata: providerMetadataWithDefaults<UnknownErrorMetadata>(),
   http: Schema.optional(HttpContext)
 }) {
   /**