effect 4.0.0-beta.103 → 4.0.0-beta.104

package/src/ExecutionPlan.ts

@@ -10,7 +10,9 @@
  * @since 3.16.0
  */
 import type { NonEmptyReadonlyArray } from "./Array.ts"
+import type * as Cause from "./Cause.ts"
 import * as Context from "./Context.ts"
+import type * as Duration from "./Duration.ts"
 import type * as Effect from "./Effect.ts"
 import { constant } from "./Function.ts"
 import * as effect from "./internal/effect.ts"
@@ -179,7 +181,7 @@ export const make = <const Steps extends NonEmptyReadonlyArray<make.Step>>(
     | (Steps[number]["schedule"] extends Schedule.Schedule<infer _O, infer _I, infer R> ? R : never)
 }> =>
   makeProto(steps.map((options, i) => {
-    if (options.attempts && options.attempts < 1) {
+    if (options.attempts !== undefined && options.attempts < 1) {
       throw new Error(`ExecutionPlan.make: step[${i}].attempts must be greater than 0`)
     }
     return {
@@ -372,3 +374,78 @@ export const CurrentMetadata = Context.Reference<Metadata>("effect/ExecutionPlan
     stepIndex: 0
   })
 })
+
+/**
+ * Lifecycle event emitted before an execution-plan attempt runs.
+ *
+ * **Details**
+ *
+ * `attempt` is the cumulative 1-based attempt number across all steps and
+ * matches `CurrentMetadata.attempt` for the same attempt. `stepAttempt` is the
+ * 1-based attempt number within the current step, and `stepIndex` is the
+ * 0-based index of the step being attempted.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface AttemptStart {
+  readonly _tag: "AttemptStart"
+  readonly attempt: number
+  readonly stepAttempt: number
+  readonly stepIndex: number
+}
+
+/**
+ * Lifecycle event emitted when an execution-plan attempt succeeds.
+ *
+ * **Details**
+ *
+ * A successful attempt completes the plan, so this is always the final event.
+ * `duration` is the elapsed time of the attempt.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface AttemptSuccess {
+  readonly _tag: "AttemptSuccess"
+  readonly attempt: number
+  readonly stepAttempt: number
+  readonly stepIndex: number
+  readonly duration: Duration.Duration
+}
+
+/**
+ * Lifecycle event emitted when an execution-plan attempt fails.
+ *
+ * **Details**
+ *
+ * `cause` holds the full failure cause, so defects and interruption are
+ * reported as well as expected errors. Whether the plan retries or fails over
+ * afterwards is decided by the step's `attempts`, `while`, and `schedule`; a
+ * following `AttemptStart` indicates another attempt was made.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface AttemptFailure<E> {
+  readonly _tag: "AttemptFailure"
+  readonly attempt: number
+  readonly stepAttempt: number
+  readonly stepIndex: number
+  readonly duration: Duration.Duration
+  readonly cause: Cause.Cause<E>
+}
+
+/**
+ * Union of the lifecycle events emitted while an execution plan runs.
+ *
+ * **Details**
+ *
+ * Every `AttemptStart` is followed by exactly one terminal event, either
+ * `AttemptSuccess` or `AttemptFailure`. An interrupted attempt emits
+ * `AttemptFailure` with the interruption cause.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type Event<E> = AttemptStart | AttemptSuccess | AttemptFailure<E>

package/src/FiberSet.ts

@@ -100,7 +100,7 @@ const Proto = {
   ...PipeInspectableProto,
   toJSON(this: FiberSet<unknown, unknown>) {
     return {
-      _id: "FiberMap",
+      _id: "FiberSet",
       state: this.state
     }
   }

package/src/FileSystem.ts

@@ -1010,7 +1010,7 @@ export const isFile = (u: unknown): u is File => hasProperty(u, FileTypeId)
  * const file: FileSystem.File = {
  *   [FileSystem.FileTypeId]: FileSystem.FileTypeId,
  *   stat: Effect.succeed({ size: FileSystem.Size(5) } as FileSystem.File.Info),
- *   seek: () => Effect.void,
+ *   seek: () => Effect.succeed(FileSystem.Size(0)),
  *   sync: Effect.void,
  *   read: (buffer) => Effect.sync(() => {
  *     buffer.set([1, 2, 3, 4, 5])
@@ -1040,7 +1040,7 @@ export const isFile = (u: unknown): u is File => hasProperty(u, FileTypeId)
 export interface File {
   readonly [FileTypeId]: typeof FileTypeId
   readonly stat: Effect.Effect<File.Info, PlatformError>
-  readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>
+  readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<Size>
   readonly sync: Effect.Effect<void, PlatformError>
   readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError>
   readonly readAlloc: (size: SizeInput) => Effect.Effect<Option.Option<Uint8Array>, PlatformError>

package/src/Function.ts

@@ -1493,11 +1493,12 @@ export const SK = <A, B>(_: A, b: B): B => b
  * **Details**
  *
  * Each memoized wrapper owns a private `WeakMap` keyed by object identity.
- * Cached `undefined` results are still returned because the cache is checked
- * with `WeakMap.has`.
  *
  * **Gotchas**
  *
+ * `undefined` is reserved to represent a cache miss and is therefore not
+ * supported as a return value.
+ *
  * Structurally equal objects do not share cache entries. If the same object is
  * mutated after its first call, later calls still return the cached result for
  * that reference.
@@ -1505,12 +1506,11 @@ export const SK = <A, B>(_: A, b: B): B => b
  * @category caching
  * @since 4.0.0
  */
-export function memoize<A extends object, O>(f: (a: A) => O): (ast: A) => O {
+export function memoize<A extends object, O extends {} | null>(f: (a: A) => O): (ast: A) => O {
   const cache = new WeakMap<object, O>()
   return (a) => {
-    if (cache.has(a)) {
-      return cache.get(a)!
-    }
+    const cached = cache.get(a)
+    if (cached !== undefined) return cached
     const result = f(a)
     cache.set(a, result)
     return result

package/src/Iterable.ts

@@ -3276,19 +3276,20 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
     const outerIterator = self[Symbol.iterator]()
     let innerIterator: Iterator<A> | undefined
     function next() {
-      if (innerIterator === undefined) {
-        const next = outerIterator.next()
-        if (next.done) {
-          return next
+      while (true) {
+        if (innerIterator === undefined) {
+          const next = outerIterator.next()
+          if (next.done) {
+            return next
+          }
+          innerIterator = next.value[Symbol.iterator]()
+        }
+        const result = innerIterator.next()
+        if (!result.done) {
+          return result
         }
-        innerIterator = next.value[Symbol.iterator]()
-      }
-      const result = innerIterator.next()
-      if (result.done) {
         innerIterator = undefined
-        return next()
       }
-      return result
     }
     return { next }
   }

package/src/Layer.ts

@@ -447,11 +447,13 @@ class MemoMapImpl implements MemoMap {
     scope: Scope.Scope,
     build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<ROut>, E, RIn>
   ): Effect<Context.Context<ROut>, E, RIn> {
-    const existing = this.get(layer, scope)
-    if (existing) {
-      return existing
-    }
-    return memoMapBuild(this, layer, scope, build)
+    return internalEffect.suspend(() => {
+      const existing = this.get(layer, scope)
+      if (existing) {
+        return existing
+      }
+      return memoMapBuild(this, layer, scope, build)
+    })
   }
 }
 

package/src/Schedule.ts

@@ -538,14 +538,14 @@ export const addDelay: {
  * ```ts import.meta.vitest
  * import { Schedule } from "effect"
  *
- * const schedule = Schedule.andThen(Schedule.recurs(1), Schedule.recurs(2))
+ * const schedule = Schedule.concat(Schedule.recurs(1), Schedule.recurs(2))
  * Schedule.isSchedule(schedule) // => true
  * ```
  *
  * @category sequencing
  * @since 2.0.0
  */
-export const andThen: {
+export const concat: {
   /**
    * Returns a schedule that runs `self` to completion, then runs `other`, and
    * merges their outputs.
@@ -555,7 +555,7 @@ export const andThen: {
    * ```ts import.meta.vitest
    * import { Schedule } from "effect"
    *
-   * const schedule = Schedule.andThen(Schedule.recurs(1), Schedule.recurs(2))
+   * const schedule = Schedule.concat(Schedule.recurs(1), Schedule.recurs(2))
    * Schedule.isSchedule(schedule) // => true
    * ```
    *
@@ -574,7 +574,7 @@ export const andThen: {
    * ```ts import.meta.vitest
    * import { Schedule } from "effect"
    *
-   * const schedule = Schedule.andThen(Schedule.recurs(1), Schedule.recurs(2))
+   * const schedule = Schedule.concat(Schedule.recurs(1), Schedule.recurs(2))
    * Schedule.isSchedule(schedule) // => true
    * ```
    *
@@ -589,7 +589,7 @@ export const andThen: {
   self: Schedule<Output, Input, Error, Env>,
   other: Schedule<Output2, Input2, Error2, Env2>
 ): Schedule<Output | Output2, Input & Input2, Error | Error2, Env | Env2> =>
-  map(andThenResult(self, other), ({ output }) => effect.succeed(Result.merge(output))))
+  map(concatResult(self, other), ({ output }) => effect.succeed(Result.merge(output))))
 
 /**
  * Returns a schedule that runs `self` to completion, then runs `other`, and
@@ -606,14 +606,14 @@ export const andThen: {
  * ```ts import.meta.vitest
  * import { Schedule } from "effect"
  *
- * const schedule = Schedule.andThenResult(Schedule.recurs(1), Schedule.recurs(2))
+ * const schedule = Schedule.concatResult(Schedule.recurs(1), Schedule.recurs(2))
  * Schedule.isSchedule(schedule) // => true
  * ```
  *
  * @category sequencing
  * @since 4.0.0
  */
-export const andThenResult: {
+export const concatResult: {
   /**
    * Returns a schedule that runs `self` to completion, then runs `other`, and
    * preserves which schedule produced each output.
@@ -629,7 +629,7 @@ export const andThenResult: {
    * ```ts import.meta.vitest
    * import { Schedule } from "effect"
    *
-   * const schedule = Schedule.andThenResult(Schedule.recurs(1), Schedule.recurs(2))
+   * const schedule = Schedule.concatResult(Schedule.recurs(1), Schedule.recurs(2))
    * Schedule.isSchedule(schedule) // => true
    * ```
    *
@@ -654,7 +654,7 @@ export const andThenResult: {
    * ```ts import.meta.vitest
    * import { Schedule } from "effect"
    *
-   * const schedule = Schedule.andThenResult(Schedule.recurs(1), Schedule.recurs(2))
+   * const schedule = Schedule.concatResult(Schedule.recurs(1), Schedule.recurs(2))
    * Schedule.isSchedule(schedule) // => true
    * ```
    *
@@ -707,7 +707,7 @@ export const andThenResult: {
          * ```ts import.meta.vitest
          * import { Schedule } from "effect"
          *
-         * const schedule = Schedule.andThenResult(Schedule.recurs(1), Schedule.recurs(2))
+         * const schedule = Schedule.concatResult(Schedule.recurs(1), Schedule.recurs(2))
          * Schedule.isSchedule(schedule) // => true
          * ```
          *
@@ -730,7 +730,7 @@ export const andThenResult: {
          * ```ts import.meta.vitest
          * import { Schedule } from "effect"
          *
-         * const schedule = Schedule.andThenResult(Schedule.recurs(1), Schedule.recurs(2))
+         * const schedule = Schedule.concatResult(Schedule.recurs(1), Schedule.recurs(2))
          * Schedule.isSchedule(schedule) // => true
          * ```
          *
@@ -753,7 +753,7 @@ export const andThenResult: {
          * ```ts import.meta.vitest
          * import { Schedule } from "effect"
          *
-         * const schedule = Schedule.andThenResult(Schedule.recurs(1), Schedule.recurs(2))
+         * const schedule = Schedule.concatResult(Schedule.recurs(1), Schedule.recurs(2))
          * Schedule.isSchedule(schedule) // => true
          * ```
          *
@@ -776,7 +776,7 @@ export const andThenResult: {
          * ```ts import.meta.vitest
          * import { Schedule } from "effect"
          *
-         * const schedule = Schedule.andThenResult(Schedule.recurs(1), Schedule.recurs(2))
+         * const schedule = Schedule.concatResult(Schedule.recurs(1), Schedule.recurs(2))
          * Schedule.isSchedule(schedule) // => true
          * ```
          *

package/src/Schema.ts

@@ -10524,17 +10524,17 @@ function causeToFormatter<E>(error: Formatter<E>, defect: Formatter<unknown>) {
 }
 
 /**
- * Type-level representation of {@link Error}.
+ * Type-level representation of {@link ErrorInstance}.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Error extends instanceOf<globalThis.Error> {
-  readonly "Rebuild": Error
+export interface ErrorInstance extends instanceOf<globalThis.Error> {
+  readonly "Rebuild": ErrorInstance
 }
 
 /**
- * Options for {@link Error} and {@link Defect}.
+ * Options for {@link ErrorInstance} and {@link Defect}.
  *
  * @category options
  * @since 4.0.0
@@ -10597,7 +10597,7 @@ const getErrorOptions = (key: ErrorOptionsKey): NormalizedErrorOptions | undefin
   }
 }
 
-const errorSchemaCache: Array<Error | undefined> = []
+const errorSchemaCache: Array<ErrorInstance | undefined> = []
 
 /**
  * Schema for JavaScript `Error` objects.
@@ -10614,7 +10614,7 @@ const errorSchemaCache: Array<Error | undefined> = []
  * @category schemas
  * @since 4.0.0
  */
-export function Error(options?: ErrorOptions): Error {
+export function ErrorInstance(options?: ErrorOptions): ErrorInstance {
   const key = getErrorOptionsKey(options)
   const cached = errorSchemaCache[key]
   if (cached !== undefined) {
@@ -10627,7 +10627,9 @@ export function Error(options?: ErrorOptions): Error {
       payload: normalizedOptions ?? null
     },
     toCode: () => ({
-      runtime: normalizedOptions !== undefined ? `Schema.Error(${format(normalizedOptions)})` : `Schema.Error()`,
+      runtime: normalizedOptions !== undefined
+        ? `Schema.ErrorInstance(${format(normalizedOptions)})`
+        : `Schema.ErrorInstance()`,
       Type: `globalThis.Error`
     }),
     expected: "Error",
@@ -10639,22 +10641,22 @@ export function Error(options?: ErrorOptions): Error {
 }
 
 /**
- * Reviver for persisted {@link Error} declarations.
+ * Reviver for persisted {@link ErrorInstance} declarations.
  *
  * **When to use**
  *
- * Use when reconstructing documents that may contain schemas created by {@link Error}.
+ * Use when reconstructing documents that may contain schemas created by {@link ErrorInstance}.
  *
- * @see {@link Error} for creating the corresponding schema
+ * @see {@link ErrorInstance} for creating the corresponding schema
  *
  * @category schemas
  * @since 4.0.0
  */
-export const ErrorReviver = InternalSchema.makeDeclarationReviver(
+export const ErrorInstanceReviver = InternalSchema.makeDeclarationReviver(
   "effect/schema/Error",
   ErrorRepresentationPayload,
   ({ annotations, payload }) => {
-    const schema = Error(payload ?? undefined)
+    const schema = ErrorInstance(payload ?? undefined)
     return annotations === undefined ? schema : schema.annotate(annotations)
   }
 )
@@ -10708,7 +10710,7 @@ const defectSchemaCache: Array<Defect | undefined> = []
  * - Values that cannot be represented as JSON fall back to Effect's formatted
  *   string representation.
  *
- * @see {@link Error} for a schema that only accepts JavaScript `Error` values.
+ * @see {@link ErrorInstance} for a schema that only accepts JavaScript `Error` values.
  * @category schemas
  * @since 4.0.0
  */
@@ -14129,19 +14131,26 @@ function getClassSchemaFactory<S extends Constraint>(
     if (memo !== undefined) {
       return memo
     }
+    const ClassTypeId = getClassTypeId(identifier)
+    const isClassValue: Predicate.Predicate<unknown> = (input) =>
+      input instanceof self || Predicate.hasProperty(input, ClassTypeId)
     const transformation = getClassTransformation(self)
     const to = make<declareConstructor<Self, S["Encoded"], readonly [S]>>(
       new SchemaAST.Declaration(
         [from.ast],
         () => (input, ast) => {
-          return input instanceof self ||
-              Predicate.hasProperty(input, getClassTypeId(identifier)) ?
+          return isClassValue(input) ?
             Effect.succeed(input) :
             Effect.fail(new SchemaIssue.InvalidType(ast))
         },
         {
           identifier,
-          [SchemaAST.ClassTypeId]: ([from]: readonly [SchemaAST.AST]) => new SchemaAST.Link(from, transformation),
+          [InternalAnnotations.CONSTRUCTOR_ANNOTATION_KEY]: (
+            [from]: readonly [SchemaAST.AST]
+          ): SchemaAST.ConstructorDescriptor => ({
+            isConstructed: isClassValue,
+            link: new SchemaAST.Link(from, transformation)
+          }),
           toCodec: ([from]: readonly [ConstraintCodec<S["Encoded"], S["Encoded"]>]) =>
             new SchemaAST.Link(from.ast, transformation),
           toArbitrary: ([from]: readonly [Annotations.ToArbitrary.TypeParameter<S["Type"]>]) => () => ({
@@ -14228,8 +14237,8 @@ type MissingSelfGeneric<Usage extends string> =
  * ```
  *
  * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
- * @see {@link ErrorClass} for defining schema-backed error classes
- * @see {@link TaggedErrorClass} for defining tagged schema-backed error classes
+ * @see {@link Error} for defining schema-backed error classes
+ * @see {@link TaggedError} for defining tagged schema-backed error classes
  *
  * @category constructors
  * @since 3.10.0
@@ -14298,8 +14307,8 @@ export const Class: {
    * ```
    *
    * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
-   * @see {@link ErrorClass} for defining schema-backed error classes
-   * @see {@link TaggedErrorClass} for defining tagged schema-backed error classes
+   * @see {@link Error} for defining schema-backed error classes
+   * @see {@link TaggedError} for defining tagged schema-backed error classes
    *
    * @category constructors
    * @since 3.10.0
@@ -14368,8 +14377,8 @@ export const Class: {
      * ```
      *
      * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
-     * @see {@link ErrorClass} for defining schema-backed error classes
-     * @see {@link TaggedErrorClass} for defining tagged schema-backed error classes
+     * @see {@link Error} for defining schema-backed error classes
+     * @see {@link TaggedError} for defining tagged schema-backed error classes
      *
      * @category constructors
      * @since 3.10.0
@@ -14441,8 +14450,8 @@ export const Class: {
      * ```
      *
      * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
-     * @see {@link ErrorClass} for defining schema-backed error classes
-     * @see {@link TaggedErrorClass} for defining tagged schema-backed error classes
+     * @see {@link Error} for defining schema-backed error classes
+     * @see {@link TaggedError} for defining tagged schema-backed error classes
      *
      * @category constructors
      * @since 3.10.0
@@ -14634,7 +14643,7 @@ export const TaggedClass: {
  * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
- * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
+ * class NotFound extends Schema.Error<NotFound>("NotFound")({
  *   id: Schema.Number
  * }) {}
  *
@@ -14648,7 +14657,7 @@ export const TaggedClass: {
  * @category constructors
  * @since 4.0.0
  */
-export const ErrorClass: {
+export const Error: {
   /**
    * Creates a schema-backed error class that can be used as a typed,
    * yieldable error in Effect programs. Combines {@link Class} validation with
@@ -14660,7 +14669,7 @@ export const ErrorClass: {
    * ```ts import.meta.vitest
    * import { Effect, Schema } from "effect"
    *
-   * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
+   * class NotFound extends Schema.Error<NotFound>("NotFound")({
    *   id: Schema.Number
    * }) {}
    *
@@ -14686,7 +14695,7 @@ export const ErrorClass: {
      * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
-     * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
+     * class NotFound extends Schema.Error<NotFound>("NotFound")({
      *   id: Schema.Number
      * }) {}
      *
@@ -14703,7 +14712,7 @@ export const ErrorClass: {
     <const Fields extends Struct.Fields>(
       fields: Fields,
       annotations?: Annotations.Declaration<Self, readonly [Struct<Fields>]>
-    ): [Self] extends [never] ? MissingSelfGeneric<"Schema.ErrorClass">
+    ): [Self] extends [never] ? MissingSelfGeneric<"Schema.Error">
       : Class<Self, Struct<Fields>, Cause_.YieldableError & Brand>
     /**
      * Creates a schema-backed error class that can be used as a typed,
@@ -14716,7 +14725,7 @@ export const ErrorClass: {
      * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
-     * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
+     * class NotFound extends Schema.Error<NotFound>("NotFound")({
      *   id: Schema.Number
      * }) {}
      *
@@ -14730,13 +14739,13 @@ export const ErrorClass: {
      * @category constructors
      * @since 4.0.0
      */
-    <S extends Struct<Struct.Fields>>(schema: S, annotations?: Annotations.Declaration<Self, readonly [S]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.ErrorClass"> : Class<Self, S, Cause_.YieldableError & Brand>
+    <S extends Struct<Struct.Fields>>(schema: S, annotations?: Annotations.Declaration<Self, readonly [S]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.Error"> : Class<Self, S, Cause_.YieldableError & Brand>
   }
 } = <Self, Brand = {}>(identifier: string) =>
 (
   schema: Struct.Fields | Struct<Struct.Fields>,
   annotations?: Annotations.Declaration<Self, readonly [Struct<Struct.Fields>]>
-): [Self] extends [never] ? MissingSelfGeneric<"Schema.ErrorClass">
+): [Self] extends [never] ? MissingSelfGeneric<"Schema.Error">
   : Class<Self, Struct<Struct.Fields>, Cause_.YieldableError & Brand> =>
 {
   const struct = isStruct(schema) ? schema : Struct(schema)
@@ -14766,7 +14775,7 @@ export const ErrorClass: {
  * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
- * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
+ * class NotFound extends Schema.TaggedError<NotFound>()("NotFound", {
  *   id: Schema.Number
  * }) {}
  *
@@ -14781,7 +14790,7 @@ export const ErrorClass: {
  * @category constructors
  * @since 3.10.0
  */
-export const TaggedErrorClass: {
+export const TaggedError: {
   /**
    * Defines a schema-backed yieldable error class with an automatically populated
    * `_tag` field.
@@ -14796,7 +14805,7 @@ export const TaggedErrorClass: {
    * ```ts import.meta.vitest
    * import { Effect, Schema } from "effect"
    *
-   * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
+   * class NotFound extends Schema.TaggedError<NotFound>()("NotFound", {
    *   id: Schema.Number
    * }) {}
    *
@@ -14826,7 +14835,7 @@ export const TaggedErrorClass: {
      * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
-     * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
+     * class NotFound extends Schema.TaggedError<NotFound>()("NotFound", {
      *   id: Schema.Number
      * }) {}
      *
@@ -14845,7 +14854,7 @@ export const TaggedErrorClass: {
       tag: Tag,
       fields: Fields,
       annotations?: Annotations.Declaration<Self, readonly [TaggedStruct<Tag, Fields>]>
-    ): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedErrorClass">
+    ): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedError">
       : Class<Self, TaggedStruct<Tag, Fields>, Cause_.YieldableError & Brand>
     /**
      * Defines a schema-backed yieldable error class with an automatically populated
@@ -14861,7 +14870,7 @@ export const TaggedErrorClass: {
      * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
-     * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
+     * class NotFound extends Schema.TaggedError<NotFound>()("NotFound", {
      *   id: Schema.Number
      * }) {}
      *
@@ -14883,7 +14892,7 @@ export const TaggedErrorClass: {
         Self,
         readonly [Struct<Simplify<{ readonly _tag: tag<Tag> } & S["fields"]>>]
       >
-    ): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedErrorClass">
+    ): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedError">
       : Class<Self, Struct<Simplify<{ readonly _tag: tag<Tag> } & S["fields"]>>, Cause_.YieldableError & Brand>
   }
 } = (identifier?: string) => {
@@ -14897,7 +14906,7 @@ export const TaggedErrorClass: {
         unsafePreserveChecks: true
       }) :
       TaggedStruct(tagValue, schema)
-    return ErrorClass<any, {}>(identifier ?? tagValue)(
+    return Error<any, {}>(identifier ?? tagValue)(
       struct,
       annotations as Annotations.Declaration<any, readonly [typeof struct]>
     )
@@ -15385,7 +15394,7 @@ const toCodecJsonASTBase = SchemaAST.applyToSelfOrLastLinkEncoding((ast) => {
 export const toCodecJsonAST = memoize(toCodecJsonASTBase)
 
 function withoutConstructorDefault(context: SchemaAST.Context): SchemaAST.Context {
-  return context.defaultValue === undefined ?
+  return context.constructorDefault === undefined ?
     context :
     new SchemaAST.Context(context.isOptional, context.isMutable, undefined, context.annotations)
 }