effect-app 4.0.0-beta.23 → 4.0.0-beta.230

package/src/Effect.ts

@@ -2,11 +2,13 @@
 /* eslint-disable prefer-destructuring */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
-import { Effect, Option, Ref, type ServiceMap } from "effect"
 import * as Def from "effect/Deferred"
-import * as Fiber from "effect/Fiber"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Ref from "effect/Ref"
 import type { Scope } from "effect/Scope"
 import type { Semaphore } from "effect/Semaphore"
+import type * as Context from "./Context.js"
 import { curry } from "./Function.js"
 import { typedKeysOf } from "./utils.js"
 
@@ -111,15 +113,11 @@ export function modifyWithPermitWithEffect<A>(ref: Ref.Ref<A>, semaphore: Semaph
     )
 }
 
-export function joinAll<E, A>(fibers: Iterable<Fiber.Fiber<A, E>>): Effect.Effect<readonly A[], E> {
-  return Fiber.joinAll(fibers) as any
-}
-
 type ServiceA<T> = T extends Effect.Effect<infer S, any, any> ? S
-  : T extends ServiceMap.Service<any, infer S> ? S
+  : T extends Context.Service<any, infer S> ? S
   : never
 type ServiceR<T> = T extends Effect.Effect<any, any, infer R> ? R
-  : T extends ServiceMap.Service<infer I, any> ? I
+  : T extends Context.Service<infer I, any> ? I
   : never
 type ServiceE<T> = T extends Effect.Effect<any, infer E, any> ? E : never
 // type Values<T> = T extends { [s: string]: infer S } ? ServiceA<S> : never
@@ -140,28 +138,30 @@ type ValuesE<T> = T extends { [s: string]: infer S } ? ServiceE<S> : never
  * const b = a({ str: "" })   // valid, but shouldn't be!
  * ```
  */
+// eslint-disable-next-line import/namespace
 export interface EffectUnunified<R, E, A> extends Effect.Effect<R, E, A> {}
 
 export type LowerFirst<S extends PropertyKey> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}`
   : S
-export type LowerServices<T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>> = {
+export type LowerServices<T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>> = {
   [key in keyof T as LowerFirst<key>]: ServiceA<T[key]>
 }
 
-export function allLower<T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>>(
+export function allLower<T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>>(
   services: T
 ) {
   return Effect.all(
     typedKeysOf(services).reduce((prev, cur) => {
-      const svc = services[cur]
-      prev[((cur as string)[0]!.toLowerCase() + (cur as string).slice(1)) as unknown as LowerFirst<typeof cur>] = svc // "_id" in svc && svc._id === TagTypeId ? svc : svc
+      const svc = services[cur]!
+      prev[((cur as string)[0]!.toLowerCase() + (cur as string).slice(1)) as unknown as LowerFirst<typeof cur>] =
+        "asEffect" in svc ? svc.asEffect() : svc
       return prev
     }, {} as any),
     { concurrency: "inherit" }
   ) as any as Effect.Effect<LowerServices<T>, ValuesE<T>, ValuesR<T>>
 }
 
-export function allLowerWith<T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>, A>(
+export function allLowerWith<T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>, A>(
   services: T,
   fn: (services: LowerServices<T>) => A
 ) {
@@ -169,7 +169,7 @@ export function allLowerWith<T extends Record<string, ServiceMap.Service<any, an
 }
 
 export function allLowerWithEffect<
-  T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>,
+  T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>,
   R,
   E,
   A

package/src/Layer.ts

@@ -1,6 +1,11 @@
-import { type Array, Effect, Layer, type Scope, type ServiceMap, type Types } from "effect"
+import type * as Array from "effect/Array"
+import * as Effect from "effect/Effect"
 import { type Yieldable } from "effect/Effect"
 import { dual } from "effect/Function"
+import * as Layer from "effect/Layer"
+import type * as Scope from "effect/Scope"
+import type * as Types from "effect/Types"
+import type * as Context from "./Context.js"
 import { type EffectGenUtils } from "./utils/gen.js"
 
 export * from "effect/Layer"
@@ -11,13 +16,13 @@ type MakeEff<S, E, R> = {
   readonly make: Effect.Effect<S, E, R>
 }
 type MakeGen<S, E = never, R = never> = {
-  readonly make: () => Generator<Yieldable<any, any, E, R>, S, any>
+  readonly make: () => Generator<Yieldable<any, any, E, R>, S>
 }
 type MakeGenNo<S> = {
   readonly make: () => Generator<unknown, S>
 }
 type MakeErr<Opts> = Opts extends { make: () => any } ? EffectGenUtils.Error<Opts["make"]> : never
-type MakeContext<Opts> = Opts extends { make: () => any } ? EffectGenUtils.ServiceMap<Opts["make"]> : never
+type MakeContext<Opts> = Opts extends { make: () => any } ? EffectGenUtils.Context<Opts["make"]> : never
 
 type DependenciesOpt = { dependencies?: Array.NonEmptyReadonlyArray<Layer.Any> }
 type Dependencies = { dependencies: Array.NonEmptyReadonlyArray<Layer.Any> }
@@ -41,12 +46,12 @@ type PackedOrUnpackedLayer<I, Opts> = Opts extends Dependencies ? PackedLayers<I
 
 export const make: {
   <I, S>(
-    tag: ServiceMap.Service<I, S>
+    tag: Context.Service<I, S>
   ): <Opts extends Make<Types.NoInfer<S>, any, any>>(
     options: Opts
   ) => PackedOrUnpackedLayer<I, Opts>
   <I, S, Opts extends Make<Types.NoInfer<S>, any, any>>(
-    tag: ServiceMap.Service<I, S>,
+    tag: Context.Service<I, S>,
     options: Opts
   ): PackedOrUnpackedLayer<I, Opts>
 } = dual(2, (tag, options) => {

package/src/NonEmptySet.ts

@@ -1,5 +1,7 @@
-import { type Equivalence, Option, type Order } from "effect"
 import type { NonEmptyReadonlyArray } from "effect/Array"
+import type * as Equivalence from "effect/Equivalence"
+import * as Option from "effect/Option"
+import type * as Order from "effect/Order"
 import { flow, pipe } from "./Function.js"
 import { filter_, filterMap, filterMap_, fromArray as fromArrayOriginal, insert as insertOriginal, insert_ as insert_Original, map, map_, reduce, reduce_, remove, remove_, type Set, toArray as toArrayOriginal } from "./Set.js"
 

package/src/Option.ts

@@ -2,6 +2,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+// eslint-disable-next-line import/no-unassigned-import
+import "./builtin.js"
 import { getOrUndefined as value, type Some } from "effect/Option"
 import * as Option from "effect/Option"
 

package/src/Pure.ts

@@ -1,7 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Chunk, Effect, Layer, Result } from "effect"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Result from "effect/Result"
+import * as Context from "./Context.js"
 import { tuple } from "./Function.js"
-import * as ServiceMap from "./ServiceMap.js"
 
 const S1 = Symbol()
 const S2 = Symbol()
@@ -86,9 +89,9 @@ export function GMU<W, S, S2, GA, MR, ME>(modify: (i: GA) => Pure<W, S, S2, MR,
   ) => GMU_(get, modify, update)
 }
 
-const tagg = ServiceMap.Service<{ env: PureEnv<never, unknown, never> }>("PureEnv")
+const tagg = Context.Service<{ env: PureEnv<never, unknown, never> }>("PureEnv")
 function castTag<W, S, S2>() {
-  return tagg as any as ServiceMap.Service<PureEnvEnv<W, S, S2>, PureEnvEnv<W, S, S2>>
+  return tagg as any as Context.Service<PureEnvEnv<W, S, S2>, PureEnvEnv<W, S, S2>>
 }
 
 export const ServiceTag = Symbol()
@@ -100,9 +103,9 @@ export abstract class PhantomTypeParameter<Identifier extends keyof any, Instant
   }
 }
 
-export type ServiceShape<T extends ServiceMap.ServiceClass.Shape<any, any>> = Omit<
+export type ServiceShape<T extends Context.ServiceClass.Shape<any, any>> = Omit<
   T,
-  keyof ServiceMap.ServiceClass.Shape<any, any>
+  keyof Context.ServiceClass.Shape<any, any>
 >
 
 export abstract class ServiceTagged<ServiceKey> extends PhantomTypeParameter<string, ServiceKey> {}
@@ -117,11 +120,11 @@ export interface PureEnvEnv<W, S, S2> extends ServiceTagged<typeof PureEnvEnv> {
 }
 
 export function get<S>(): Pure<never, S, S, never, never, S> {
-  return (castTag<never, S, S>() as any).use((_: any) => _.env.state)
+  return (castTag<never, S, S>()).useSync((_) => _.env.state)
 }
 
 export function set<S>(s: S): Pure<never, S, S, never, never, void> {
-  return (castTag<never, S, S>() as any).use((_: any) => {
+  return (castTag<never, S, S>()).useSync((_) => {
     _.env.state = s
   })
 }
@@ -129,13 +132,13 @@ export function set<S>(s: S): Pure<never, S, S, never, never, void> {
 export type PureLogT<W> = Pure<W, unknown, never, never, never, void>
 
 export function log<W>(w: W): PureLogT<W> {
-  return (castTag<W, unknown, never>() as any).use((_: any) => {
+  return (castTag<W, unknown, never>()).useSync((_) => {
     _.env.log = Chunk.append(_.env.log, w)
   })
 }
 
 export function logMany<W>(w: Iterable<W>): PureLogT<W> {
-  return (castTag<W, unknown, never>() as any).use((_: any) => {
+  return (castTag<W, unknown, never>()).useSync((_) => {
     _.env.log = Chunk.appendAll(_.env.log, Chunk.fromIterable(w))
   })
 }
@@ -150,17 +153,16 @@ export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
 > {
   const a = Effect
     .flatMap(self, (x) =>
-      (castTag<W3, S1, S3>() as any)
-        .use(
-          ({ env: _ }: any) => Effect.sync(() => ({ log: _.log, state: _.state }))
+      (castTag<W3, S1, S3>())
+        .useSync(
+          ({ env: _ }) => ({ log: _.log, state: _.state })
         )
         .pipe(
-          Effect.flatMap((_: any) => Effect.succeed(_)),
           Effect.map(
-            ({ log, state }: any) => tuple(log, Result.succeed(tuple(state, x)))
+            ({ log, state }) => tuple(log, Result.succeed(tuple(state, x)))
           )
         ))
-    .pipe(Effect.catch((err: any) => (tagg as any).use((env: any) => tuple(env.env.log, Result.fail(err)))))
+    .pipe(Effect.catch((err: any) => tagg.useSync((env) => tuple(env.env.log, Result.fail(err)))))
   return Effect.provide(a, Layer.succeed(tagg, { env: makePureEnv<W3, S3, S4>(s) as any }) as any) as any
 }
 
@@ -198,11 +200,11 @@ export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
 export function modify<S2, A, S3>(
   mod: (s: S2) => readonly [S3, A]
 ): Effect.Effect<A, never, { env: PureEnv<never, S2, S3> }> {
-  return (castTag<never, S3, S2>() as any).use((_: any) => {
+  return (castTag<never, S3, S2>()).useSync((_) => {
     const [s, a] = mod(_.env.state)
     _.env.state = s as any
     return a
-  })
+  }) as any
 }
 
 export function modifyM<W, R, E, A, S2, S3>(
@@ -210,7 +212,7 @@ export function modifyM<W, R, E, A, S2, S3>(
 ): Effect.Effect<A, E, FixEnv<R, W, S2, S3>> {
   // return serviceWithEffect(_ => Ref.modifyM_(_.state, mod))
   return Effect.flatMap(
-    (castTag<W, S3, S2>() as any).use((_: any) => _),
+    (castTag<W, S3, S2>()).useSync((_) => _),
     (_: any) =>
       Effect.map(mod(_.env.state), ([s, a]: any) => {
         _.env.state = s

package/src/Schema/Class.ts

@@ -1,101 +1,311 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { pipe, Struct as Struct2 } from "effect"
-import type { Struct } from "effect/Schema"
+import type * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
 import * as S from "effect/Schema"
+import * as SchemaAST from "effect/SchemaAST"
+import * as SchemaIssue from "effect/SchemaIssue"
+import { copyOrigin } from "../utils.js"
+import { concurrencyUnbounded } from "./ext.js"
+import * as SchemaParser from "./SchemaParser.js"
 
 type ClassAnnotations<Self> = S.Annotations.Declaration<Self, readonly [any]>
 
-export interface EnhancedClass<Self, SchemaS extends S.Top & { readonly fields: Struct.Fields }, Inherited>
-  extends S.Class<Self, SchemaS, Inherited>, /* Reason for enhancement */ PropsExtensions<SchemaS["fields"]>
+export interface EnhancedClass<Self, SchemaS extends S.Top & { readonly fields: S.Struct.Fields }, Inherited>
+  extends S.Class<Self, SchemaS, Inherited>
 {
+  /**
+   * See `copyOrigin` docs in `utils.ts` for return-type design details.
+   */
+  readonly copy: ReturnType<typeof copyOrigin<new(_: any) => Self>>
 }
 type MissingSelfGeneric<Usage extends string, Params extends string = ""> =
   `Missing \`Self\` generic - use \`class Self extends ${Usage}<Self>()(${Params}{ ... })\``
 
-export interface PropsExtensions<Fields> {
-  // include: <NewProps extends S.Struct.Fields>(
-  //   fnc: (fields: Fields) => NewProps
-  // ) => NewProps
-  pick: <P extends keyof Fields>(...keys: readonly P[]) => Pick<Fields, P>
-  omit: <P extends keyof Fields>(...keys: readonly P[]) => Omit<Fields, P>
-}
-
-type HasFields<Fields extends Struct.Fields> = {
+type HasFields<Fields extends S.Struct.Fields> = {
   readonly fields: Fields
 } | {
   readonly from: HasFields<Fields>
 }
 
-export const Class: <Self = never>(identifier: string) => <Fields extends S.Struct.Fields>(
+type ClassOptions = {
+  readonly strict?: boolean
+}
+
+export declare const ExtendedSchemaNoEncoded: unique symbol
+
+export type ExtendedSchemaNoEncoded = typeof ExtendedSchemaNoEncoded
+
+type WithEncoded<SchemaS extends S.Top, Encoded> = Omit<SchemaS, "Encoded"> & { readonly Encoded: Encoded }
+
+type ExtendedSchema<SchemaS extends S.Top, Encoded> = [Encoded] extends [ExtendedSchemaNoEncoded] ? SchemaS
+  : WithEncoded<SchemaS, Encoded>
+
+export type Class<Self, S extends S.Top & { readonly fields: S.Struct.Fields }, Inherited> = EnhancedClass<
+  Self,
+  S,
+  Inherited
+>
+
+/**
+ * Build a modified Declaration that accepts struct-matching values during
+ * encoding, given the original Declaration and the class's fields.
+ */
+function makeRelaxedDeclaration(
+  ast: SchemaAST.Declaration,
+  fields: S.Struct.Fields,
+  cls: any
+): SchemaAST.Declaration {
+  const parseOptions = ast.annotations?.["parseOptions"] as SchemaAST.ParseOptions | undefined
+  const structSchema = S.Struct(fields)
+  const annotatedStruct = parseOptions ? S.toType(structSchema).annotate({ parseOptions }) : S.toType(structSchema)
+  const decodeStruct = SchemaParser.decodeUnknownEffect(annotatedStruct)
+
+  return new SchemaAST.Declaration(
+    ast.typeParameters,
+    () => (input: unknown, self: SchemaAST.Declaration, options: SchemaAST.ParseOptions) => {
+      if (input instanceof cls) {
+        return Effect.succeed(input)
+      }
+      if (input !== null && typeof input === "object") {
+        return decodeStruct(input, options)
+      }
+      return Effect.fail(new SchemaIssue.InvalidType(self, Option.some(input)))
+    },
+    ast.annotations,
+    ast.checks,
+    ast.encoding,
+    ast.context
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Class — like Schema.Class but with relaxed encoding
+// ---------------------------------------------------------------------------
+
+/**
+ * Like `Schema.Class`, but the resulting class accepts plain objects matching
+ * the struct schema during encoding — not only `instanceof` or type-id
+ * checks.
+ *
+ * @example
+ * ```ts
+ * import * as Schema from "effect/Schema"
+ * import { Class } from "./Class.js"
+ *
+ * class A extends Class<A>("A")({ a: Schema.String }) {}
+ *
+ * // Construction works as normal:
+ * new A({ a: "hello" })
+ *
+ * // Encoding accepts plain objects:
+ * Schema.encodeUnknownSync(A)({ a: "hello" }) // { a: "hello" }
+ * ```
+ */
+export const Class: <Self = never, Encoded = ExtendedSchemaNoEncoded, Brand = {}>(
+  identifier: string
+) => <Fields extends S.Struct.Fields>(
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self>
+  annotations?: ClassAnnotations<Self>,
+  options?: ClassOptions
 ) => [Self] extends [never] ? MissingSelfGeneric<"Class">
   : EnhancedClass<
     Self,
-    S.Struct<Fields>,
-    {}
-  > = (identifier) => (fields, annotations) => {
-    const cls = S.Class as any
-    return class extends cls(identifier)(fields, annotations) {
-      constructor(a: any, b = true) {
-        super(a, b)
+    ExtendedSchema<S.Struct<Fields>, Encoded>,
+    Brand
+  > = (identifier) => (fields, annotations, options) => {
+    const relaxed = options?.strict === false
+    // Build the original Schema.Class
+    const Base = (S.Class as any)(identifier)(fields, { ...concurrencyUnbounded, ...annotations })
+    // Get the original ast getter from the base class
+    const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast")!
+
+    // Cache per-class to avoid recomputing
+    const astCache = new WeakMap<any, SchemaAST.Declaration>()
+    const copyCache = new WeakMap<any, ReturnType<typeof copyOrigin>>()
+
+    return class extends Base {
+      static get copy() {
+        let cached = copyCache.get(this)
+        if (cached === undefined) {
+          cached = copyOrigin(this)
+          copyCache.set(this, cached)
+        }
+        return cached
+      }
+      static get ast(): SchemaAST.Declaration {
+        let cached = astCache.get(this)
+        if (cached !== undefined) return cached
+        // Call the original getter with `this` bound to the actual user class,
+        // so getClassSchema(this) creates a schema that uses `new this(...)`.
+        const originalAst = originalAstDescriptor.get!.call(this) as SchemaAST.Declaration
+        cached = relaxed ? makeRelaxedDeclaration(originalAst, Base.fields, this) : originalAst
+        astCache.set(this, cached)
+        return cached
+      }
+      static mapFields(f: any, options?: any) {
+        return Base.mapFields(f, options).annotate(concurrencyUnbounded)
       }
-      // static readonly include = include(fields)
-      static readonly pick = (...selection: any[]) => pipe(this["fields"], Struct2.pick(selection))
-      static readonly omit = (...selection: any[]) => pipe(this["fields"], Struct2.omit(selection))
     } as any
   }
 
-export const TaggedClass: <Self = never>(identifier?: string) => <Tag extends string, Fields extends S.Struct.Fields>(
+// ---------------------------------------------------------------------------
+// TaggedClass — like Schema.TaggedClass but with relaxed encoding
+// ---------------------------------------------------------------------------
+
+/**
+ * Like `Schema.TaggedClass`, but the resulting class accepts plain objects
+ * matching the struct schema during encoding.
+ *
+ * @example
+ * ```ts
+ * import * as Schema from "effect/Schema"
+ * import { TaggedClass } from "./Class.js"
+ *
+ * class Circle extends TaggedClass<Circle>()("Circle", {
+ *   radius: Schema.Number
+ * }) {}
+ *
+ * Schema.encodeUnknownSync(Circle)({ _tag: "Circle", radius: 5 })
+ * ```
+ */
+export const TaggedClass: <Self = never, Encoded = ExtendedSchemaNoEncoded, Brand = {}>(
+  identifier?: string
+) => <Tag extends string, Fields extends S.Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self>
-) => [Self] extends [never] ? MissingSelfGeneric<"Class">
+  annotations?: ClassAnnotations<Self>,
+  options?: ClassOptions
+) => [Self] extends [never] ? MissingSelfGeneric<"TaggedClass">
   : EnhancedClass<
     Self,
-    S.Struct<{ readonly _tag: S.tag<Tag> } & Fields>,
-    {}
-  > = (identifier) => (tag, fields, annotations) => {
-    const cls = S.TaggedClass as any
-    return class extends cls(identifier)(tag, fields, annotations) {
-      constructor(a: any, b = true) {
-        super(a, b)
+    ExtendedSchema<S.Struct<{ readonly _tag: S.tag<Tag> } & Fields>, Encoded>,
+    Brand
+  > = (identifier) => (tag, fields, annotations, options) => {
+    const relaxed = options?.strict === false
+    const Base = (S.TaggedClass as any)(identifier)(tag, fields, { ...concurrencyUnbounded, ...annotations })
+    const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast")!
+    const astCache = new WeakMap<any, SchemaAST.Declaration>()
+    const copyCache = new WeakMap<any, ReturnType<typeof copyOrigin>>()
+
+    return class extends Base {
+      static get copy() {
+        let cached = copyCache.get(this)
+        if (cached === undefined) {
+          cached = copyOrigin(this)
+          copyCache.set(this, cached)
+        }
+        return cached
+      }
+      static get ast(): SchemaAST.Declaration {
+        let cached = astCache.get(this)
+        if (cached !== undefined) return cached
+        const originalAst = originalAstDescriptor.get!.call(this) as SchemaAST.Declaration
+        cached = relaxed ? makeRelaxedDeclaration(originalAst, Base.fields, this) : originalAst
+        astCache.set(this, cached)
+        return cached
+      }
+      static mapFields(f: any, options?: any) {
+        return Base.mapFields(f, options).annotate(concurrencyUnbounded)
       }
-      // static readonly include = include(fields)
-      static readonly pick = (...selection: any[]) => pipe(this["fields"], Struct2.pick(selection))
-      static readonly omit = (...selection: any[]) => pipe(this["fields"], Struct2.omit(selection))
     } as any
   }
 
-export const ExtendedClass: <Self, _SelfFrom>(identifier: string) => <Fields extends S.Struct.Fields>(
+// ---------------------------------------------------------------------------
+// ErrorClass — like Schema.ErrorClass but with relaxed encoding
+// ---------------------------------------------------------------------------
+
+export const ErrorClass: <Self = never, Encoded = ExtendedSchemaNoEncoded, Brand = {}>(
+  identifier: string
+) => <Fields extends S.Struct.Fields>(
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self>
-) => EnhancedClass<
-  Self,
-  S.Struct<Fields>,
-  {}
-> = Class as any
-
-export interface EnhancedTaggedClass<Self, Tag extends string, Fields extends Struct.Fields, SelfFrom>
-  extends
-    EnhancedClass<
-      Self,
-      S.Struct<Fields> & { readonly Encoded: SelfFrom },
-      {}
-    >
-{
-  readonly _tag: Tag
-}
+  annotations?: ClassAnnotations<Self>,
+  options?: ClassOptions
+) => [Self] extends [never] ? MissingSelfGeneric<"ErrorClass">
+  : EnhancedClass<
+    Self,
+    ExtendedSchema<S.Struct<Fields>, Encoded>,
+    Cause.YieldableError & Brand
+  > = (identifier) => (fields, annotations, options) => {
+    const relaxed = options?.strict === false
+    const Base = (S.ErrorClass as any)(identifier)(fields, { ...concurrencyUnbounded, ...annotations })
+    const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast")!
+    const astCache = new WeakMap<any, SchemaAST.Declaration>()
+    const copyCache = new WeakMap<any, ReturnType<typeof copyOrigin>>()
+
+    return class extends Base {
+      static get copy() {
+        let cached = copyCache.get(this)
+        if (cached === undefined) {
+          cached = copyOrigin(this)
+          copyCache.set(this, cached)
+        }
+        return cached
+      }
+      static get ast(): SchemaAST.Declaration {
+        let cached = astCache.get(this)
+        if (cached !== undefined) return cached
+        const originalAst = originalAstDescriptor.get!.call(this) as SchemaAST.Declaration
+        cached = relaxed ? makeRelaxedDeclaration(originalAst, Base.fields, this) : originalAst
+        astCache.set(this, cached)
+        return cached
+      }
+      static mapFields(f: any, options?: any) {
+        return Base.mapFields(f, options).annotate(concurrencyUnbounded)
+      }
+    } as any
+  }
 
-export const ExtendedTaggedClass: <Self, SelfFrom>(
+// ---------------------------------------------------------------------------
+// TaggedErrorClass — like Schema.TaggedErrorClass but with relaxed encoding
+// ---------------------------------------------------------------------------
+
+export const TaggedErrorClass: <Self = never, Encoded = ExtendedSchemaNoEncoded, Brand = {}>(
   identifier?: string
 ) => <Tag extends string, Fields extends S.Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self>
-) => EnhancedTaggedClass<
-  Self,
-  Tag,
-  { readonly _tag: S.tag<Tag> } & Fields,
-  SelfFrom
-> = TaggedClass as any
+  annotations?: ClassAnnotations<Self>,
+  options?: ClassOptions
+) => [Self] extends [never] ? MissingSelfGeneric<"TaggedErrorClass">
+  : EnhancedClass<
+    Self,
+    ExtendedSchema<S.Struct<{ readonly _tag: S.tag<Tag> } & Fields>, Encoded>,
+    Cause.YieldableError & Brand
+  > = (identifier) => (tag, fields, annotations, options) => {
+    const relaxed = options?.strict === false
+    const Base = (S.TaggedErrorClass as any)(identifier)(tag, fields, { ...concurrencyUnbounded, ...annotations })
+    const originalAstDescriptor = Object.getOwnPropertyDescriptor(Base, "ast")!
+    const astCache = new WeakMap<any, SchemaAST.Declaration>()
+    const copyCache = new WeakMap<any, ReturnType<typeof copyOrigin>>()
+
+    return class extends Base {
+      static get copy() {
+        let cached = copyCache.get(this)
+        if (cached === undefined) {
+          cached = copyOrigin(this)
+          copyCache.set(this, cached)
+        }
+        return cached
+      }
+      static get ast(): SchemaAST.Declaration {
+        let cached = astCache.get(this)
+        if (cached !== undefined) return cached
+        const originalAst = originalAstDescriptor.get!.call(this) as SchemaAST.Declaration
+        cached = relaxed ? makeRelaxedDeclaration(originalAst, Base.fields, this) : originalAst
+        astCache.set(this, cached)
+        return cached
+      }
+      static mapFields(f: any, options?: any) {
+        return Base.mapFields(f, options).annotate(concurrencyUnbounded)
+      }
+    } as any
+  }
+
+export interface Opaque<Self, Encoded, SchemaS extends S.Top, Brand>
+  extends S.Opaque<Self, ExtendedSchema<SchemaS, Encoded>, Brand>
+{}
+
+export const Opaque: <Self, Encoded = ExtendedSchemaNoEncoded, Brand = {}>() => <S extends S.Top>(
+  schema: S
+) => Opaque<Self, Encoded, S, Brand> & Omit<S, keyof S.Top> = S.Opaque as any

package/src/Schema/SchemaParser.ts

@@ -0,0 +1,12 @@
+import * as SchemaParser from "effect/SchemaParser"
+import { withDefaultParseOptions } from "./ext.js"
+
+export * from "effect/SchemaParser"
+
+export const decodeEffectConcurrently: typeof SchemaParser.decodeEffect = withDefaultParseOptions(
+  SchemaParser.decodeEffect
+)
+
+export const decodeUnknownEffectConcurrently: typeof SchemaParser.decodeUnknownEffect = withDefaultParseOptions(
+  SchemaParser.decodeUnknownEffect
+)