Remove Zod from named errors (#26982)

packages/core/src/util/error.ts

@@ -1,8 +1,8 @@
-import z from "zod"
+import { Schema } from "effect"
 
 export abstract class NamedError extends Error {
-  abstract schema(): z.core.$ZodType
-  abstract toObject(): { name: string; data: any }
+  abstract schema(): Schema.Top
+  abstract toObject(): { name: string; data: unknown }
 
   static hasName(error: unknown, name: string): boolean {
     return (
@@ -10,30 +10,42 @@ export abstract class NamedError extends Error {
     )
   }
 
-  static create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data) {
-    const schema = z
-      .object({
-        name: z.literal(name),
-        data,
-      })
-      .meta({
-        ref: name,
-      })
+  static create<Name extends string, Fields extends Schema.Struct.Fields>(
+    name: Name,
+    fields: Fields,
+  ): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>
+  static create<Name extends string, DataSchema extends Schema.Top>(
+    name: Name,
+    data: DataSchema,
+  ): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>
+  static create<Name extends string>(name: Name, data: Schema.Top | Schema.Struct.Fields) {
+    return NamedError.createSchemaClass(name, Schema.isSchema(data) ? data : Schema.Struct(data))
+  }
+
+  private static createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema) {
+    const schema = Schema.Struct({
+      name: Schema.Literal(name),
+      data,
+    }).annotate({ identifier: name })
+    type Data = Schema.Schema.Type<DataSchema>
+
     const result = class extends NamedError {
       public static readonly Schema = schema
+      public static readonly EffectSchema = schema
+      public static readonly tag = name
 
-      public override readonly name = name as Name
+      public override readonly name = name
 
       constructor(
-        public readonly data: z.input<Data>,
+        public readonly data: Data,
         options?: ErrorOptions,
       ) {
         super(name, options)
         this.name = name
       }
 
-      static isInstance(input: any): input is InstanceType<typeof result> {
-        return typeof input === "object" && "name" in input && input.name === name
+      static isInstance(input: unknown): input is InstanceType<typeof result> {
+        return NamedError.hasName(input, name)
       }
 
       schema() {
@@ -51,10 +63,7 @@ export abstract class NamedError extends Error {
     return result
   }
 
-  public static readonly Unknown = NamedError.create(
-    "UnknownError",
-    z.object({
-      message: z.string(),
-    }),
-  )
+  public static readonly Unknown = NamedError.create("UnknownError", {
+    message: Schema.String,
+  })
 }