effect 4.0.0-beta.0 → 4.0.0-beta.10

package/src/internal/dateTime.ts

@@ -12,7 +12,6 @@ import * as Inspectable from "../Inspectable.ts"
 import * as order from "../Order.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import * as Predicate from "../Predicate.ts"
-import * as Result from "../Result.ts"
 import type { Mutable } from "../Types.ts"
 import * as UndefinedOr from "../UndefinedOr.ts"
 import * as effect from "./effect.ts"
@@ -467,32 +466,12 @@ export const setZoneNamedUnsafe: {
 
 /** @internal */
 export const distance: {
-  (other: DateTime.DateTime): (self: DateTime.DateTime) => number
-  (self: DateTime.DateTime, other: DateTime.DateTime): number
-} = dual(2, (self: DateTime.DateTime, other: DateTime.DateTime): number => toEpochMillis(other) - toEpochMillis(self))
-
-/** @internal */
-export const distanceDurationResult: {
-  (other: DateTime.DateTime): (self: DateTime.DateTime) => Result.Result<Duration.Duration, Duration.Duration>
-  (self: DateTime.DateTime, other: DateTime.DateTime): Result.Result<Duration.Duration, Duration.Duration>
-} = dual(
-  2,
-  (self: DateTime.DateTime, other: DateTime.DateTime): Result.Result<Duration.Duration, Duration.Duration> => {
-    const diffMillis = distance(self, other)
-    return diffMillis > 0
-      ? Result.succeed(Duration.millis(diffMillis))
-      : Result.fail(Duration.millis(-diffMillis))
-  }
-)
-
-/** @internal */
-export const distanceDuration: {
   (other: DateTime.DateTime): (self: DateTime.DateTime) => Duration.Duration
   (self: DateTime.DateTime, other: DateTime.DateTime): Duration.Duration
 } = dual(
   2,
   (self: DateTime.DateTime, other: DateTime.DateTime): Duration.Duration =>
-    Duration.millis(Math.abs(distance(self, other)))
+    Duration.millis(toEpochMillis(other) - toEpochMillis(self))
 )
 
 /** @internal */
@@ -911,22 +890,22 @@ export const match: {
 
 /** @internal */
 export const addDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
+  (duration: Duration.Input): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.Input): A
 } = dual(
   2,
-  (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
-    mapEpochMillis(self, (millis) => millis + Duration.toMillis(Duration.fromDurationInputUnsafe(duration)))
+  (self: DateTime.DateTime, duration: Duration.Input): DateTime.DateTime =>
+    mapEpochMillis(self, (millis) => millis + Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
 /** @internal */
 export const subtractDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
+  (duration: Duration.Input): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.Input): A
 } = dual(
   2,
-  (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
-    mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromDurationInputUnsafe(duration)))
+  (self: DateTime.DateTime, duration: Duration.Input): DateTime.DateTime =>
+    mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
 const addMillis = (date: Date, amount: number): void => {

package/src/internal/effect.ts

@@ -14,6 +14,7 @@ import { constant, constFalse, constTrue, constUndefined, constVoid, dual, ident
 import * as Hash from "../Hash.ts"
 import { toJson, toStringUnknown } from "../Inspectable.ts"
 import * as Iterable from "../Iterable.ts"
+import type * as _Latch from "../Latch.ts"
 import type * as Logger from "../Logger.ts"
 import type * as LogLevel from "../LogLevel.ts"
 import type * as Metric from "../Metric.ts"
@@ -81,6 +82,7 @@ import {
   isEffect,
   isFailReason,
   isInterruptReason,
+  isNoSuchElementError,
   makePrimitive,
   makePrimitiveProto,
   NoSuchElementError,
@@ -783,6 +785,7 @@ export const fiberJoinAll = <A extends Iterable<Fiber.Fiber<any, any>>>(self: A)
 > =>
   callback((resume) => {
     const fibers = Array.from(self)
+    if (fibers.length === 0) return resume(succeed(Arr.empty() as any))
     const out = new Array<any>(fibers.length) as Arr.NonEmptyArray<any>
     const cancels = Arr.empty<() => void>()
     let done = 0
@@ -2440,6 +2443,18 @@ export const catch_: {
   ): Effect.Effect<A | B, E2, R | R2> => catchCauseIf(self, findError as any, (e: any) => f(e)) as any
 )
 
+/** @internal */
+export const catchNoSuchElement = <A, E, R>(
+  self: Effect.Effect<A, E, R>
+): Effect.Effect<Option.Option<A>, Exclude<E, Cause.NoSuchElementError>, R> =>
+  matchEffect(self, {
+    onFailure: (error) =>
+      isNoSuchElementError(error)
+        ? succeedNone
+        : fail(error as Exclude<E, Cause.NoSuchElementError>),
+    onSuccess: succeedSome
+  })
+
 /** @internal */
 export const catchDefect: {
   <E, B, E2, R2>(
@@ -3390,24 +3405,24 @@ export const isSuccess: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect
 /** @internal */
 export const delay: {
   (
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E, R>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E, R> => andThen(sleep(duration), self)
 )
 
 /** @internal */
 export const timeoutOrElse: {
   <A2, E2, R2>(options: {
-    readonly duration: Duration.DurationInput
+    readonly duration: Duration.Input
     readonly onTimeout: LazyArg<Effect.Effect<A2, E2, R2>>
   }): <A, E, R>(
     self: Effect.Effect<A, E, R>
@@ -3415,7 +3430,7 @@ export const timeoutOrElse: {
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
     options: {
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly onTimeout: LazyArg<Effect.Effect<A2, E2, R2>>
     }
   ): Effect.Effect<A | A2, E | E2, R | R2>
@@ -3424,7 +3439,7 @@ export const timeoutOrElse: {
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
     options: {
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly onTimeout: LazyArg<Effect.Effect<A2, E2, R2>>
     }
   ): Effect.Effect<A | A2, E | E2, R | R2> =>
@@ -3437,19 +3452,19 @@ export const timeoutOrElse: {
 /** @internal */
 export const timeout: {
   (
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E | Cause.TimeoutError, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E | Cause.TimeoutError, R>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E | TimeoutError, R> =>
     timeoutOrElse(self, {
       duration,
@@ -3460,19 +3475,19 @@ export const timeout: {
 /** @internal */
 export const timeoutOption: {
   (
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<Option.Option<A>, E, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<Option.Option<A>, E, R>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<Option.Option<A>, E, R> =>
     raceFirst(
       asSome(self),
@@ -3860,19 +3875,19 @@ export const acquireUseRelease = <Resource, E, R, A, E2, R2, E3, R3>(
 
 /** @internal */
 export const cachedInvalidateWithTTL: {
-  (timeToLive: Duration.DurationInput): <A, E, R>(
+  (timeToLive: Duration.Input): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
 } = dual(2, <A, E, R>(
   self: Effect.Effect<A, E, R>,
-  ttl: Duration.DurationInput
+  ttl: Duration.Input
 ): Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]> =>
   sync(() => {
-    const ttlMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(ttl))
+    const ttlMillis = Duration.toMillis(Duration.fromInputUnsafe(ttl))
     const isFinite = Number.isFinite(ttlMillis)
     const latch = makeLatchUnsafe(false)
     let expiresAt = 0
@@ -3905,17 +3920,17 @@ export const cachedInvalidateWithTTL: {
 /** @internal */
 export const cachedWithTTL: {
   (
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Effect.Effect<A, E, R>>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): Effect.Effect<Effect.Effect<A, E, R>>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): Effect.Effect<Effect.Effect<A, E, R>> => map(cachedInvalidateWithTTL(self, timeToLive), (tuple) => tuple[0])
 )
 
@@ -4271,6 +4286,9 @@ export const filter: {
   <A>(
     predicate: Predicate.Predicate<NoInfer<A>>
   ): (elements: Iterable<A>) => Effect.Effect<Array<A>>
+  <A, B, X>(
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): (elements: Iterable<A>) => Effect.Effect<Array<B>>
   <A, B, X, E, R>(
     filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
@@ -4287,6 +4305,10 @@ export const filter: {
     elements: Iterable<A>,
     predicate: Predicate.Predicate<A>
   ): Effect.Effect<Array<A>>
+  <A, B, X>(
+    elements: Iterable<A>,
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): Effect.Effect<Array<B>>
   <A, B, X, E, R>(
     elements: Iterable<A>,
     filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
@@ -4318,6 +4340,12 @@ export const filter: {
               if (result) out.push(a)
               return void_ as any
             }
+            if (!isEffect(result)) {
+              if (!Result.isFailure(result)) {
+                out.push(result.success)
+              }
+              return void_ as any
+            }
             return map(result, (r: any) => {
               if (typeof r === "boolean") {
                 if (r) out.push(a)
@@ -4746,25 +4774,27 @@ class Semaphore {
     return this.permits - this.taken
   }
 
-  readonly take = (n: number): Effect.Effect<number> =>
-    callback<number>((resume) => {
+  readonly take = (n: number): Effect.Effect<number> => {
+    const take: Effect.Effect<number> = suspend(() => {
       if (this.free < n) {
-        const observer = () => {
-          if (this.free < n) {
-            return
+        return callback((resume) => {
+          if (this.free >= n) return resume(take)
+          const observer = () => {
+            if (this.free < n) return
+            this.waiters.delete(observer)
+            resume(take)
           }
-          this.waiters.delete(observer)
-          this.taken += n
-          resume(succeed(n))
-        }
-        this.waiters.add(observer)
-        return sync(() => {
-          this.waiters.delete(observer)
+          this.waiters.add(observer)
+          return sync(() => {
+            this.waiters.delete(observer)
+          })
         })
       }
       this.taken += n
-      return resume(succeed(n))
+      return succeed(n)
     })
+    return take
+  }
 
   updateTakenUnsafe(fiber: Fiber.Fiber<any, any>, f: (n: number) => number): Effect.Effect<number> {
     this.taken = f(this.taken)
@@ -4802,7 +4832,10 @@ class Semaphore {
 
   readonly withPermits = (n: number) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
     uninterruptibleMask((restore) =>
-      flatMap(restore(this.take(n)), (permits) => ensuring(restore(self), this.release(permits)))
+      flatMap(
+        restore(this.take(n)),
+        (permits) => onExitPrimitive(restore(self), () => this.release(permits), true)
+      )
     )
 
   readonly withPermit = this.withPermits(1)
@@ -4828,7 +4861,7 @@ export const makeSemaphore = (permits: number) => sync(() => makeSemaphoreUnsafe
 const succeedTrue = succeed(true)
 const succeedFalse = succeed(false)
 
-class Latch implements Effect.Latch {
+class Latch implements _Latch.Latch {
   waiters: Array<(_: Effect.Effect<void>) => void> = []
   scheduled = false
   private isOpen: boolean
@@ -4888,7 +4921,7 @@ class Latch implements Effect.Latch {
 }
 
 /** @internal */
-export const makeLatchUnsafe = (open?: boolean | undefined): Effect.Latch => new Latch(open ?? false)
+export const makeLatchUnsafe = (open?: boolean | undefined): _Latch.Latch => new Latch(open ?? false)
 
 /** @internal */
 export const makeLatch = (open?: boolean | undefined) => sync(() => makeLatchUnsafe(open))
@@ -5318,8 +5351,8 @@ export const clockWith = <A, E, R>(f: (clock: Clock.Clock) => Effect.Effect<A, E
   withFiber((fiber) => f(fiber.getRef(ClockRef)))
 
 /** @internal */
-export const sleep = (duration: Duration.DurationInput): Effect.Effect<void> =>
-  clockWith((clock) => clock.sleep(Duration.fromDurationInputUnsafe(duration)))
+export const sleep = (duration: Duration.Input): Effect.Effect<void> =>
+  clockWith((clock) => clock.sleep(Duration.fromInputUnsafe(duration)))
 
 /** @internal */
 export const currentTimeMillis: Effect.Effect<number> = clockWith((clock) => clock.currentTimeMillis)

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/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
@@ -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

package/src/unstable/ai/AiError.ts

@@ -247,9 +247,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))
 
 /**