effect-app 2.19.4 → 2.20.0

package/src/Effect.ts

@@ -15,10 +15,6 @@ export { ServiceStrict as Service } from "effect/Effect"
 
 export * from "effect/Effect"
 
-/**
- * @macro traced
- * @tsplus fluent effect/io/Effect flatMapOpt
- */
 export function flatMapOption<R, E, A, R2, E2, A2>(
   self: Effect.Effect<Option.Option<A>, E, R>,
   fm: (a: A) => Effect.Effect<A2, E2, R2>
@@ -30,10 +26,6 @@ export function flatMapOption<R, E, A, R2, E2, A2>(
     }))
 }
 
-/**
- * @macro traced
- * @tsplus fluent effect/io/Effect tapOpt
- */
 export function tapOption<R, E, A, R2, E2, A2>(
   self: Effect.Effect<Option.Option<A>, E, R>,
   fm: (a: A) => Effect.Effect<A2, E2, R2>
@@ -45,10 +37,6 @@ export function tapOption<R, E, A, R2, E2, A2>(
     }))
 }
 
-/**
- * @macro traced
- * @tsplus fluent effect/io/Effect zipRightOpt
- */
 export function zipRightOption<R, E, A, R2, E2, A2>(
   self: Effect.Effect<Option.Option<A>, E, R>,
   fm: Effect.Effect<A2, E2, R2>
@@ -60,10 +48,6 @@ export function zipRightOption<R, E, A, R2, E2, A2>(
     }))
 }
 
-/**
- * @macro traced
- * @tsplus fluent effect/io/Effect mapOpt
- */
 export function mapOption<R, E, A, A2>(
   self: Effect.Effect<Option.Option<A>, E, R>,
   fm: (a: A) => A2
@@ -110,15 +94,10 @@ export function ifDiff<I, R, E, A>(n: I, orig: I) {
 }
 
 // NOTE: await extension doesnt work via tsplus somehow
-/**
- * @tsplus static effect/io/Deferred.Ops await
- * @tsplus getter effect/io/Deferred await
- */
 export const await_ = Def.await
 
 /**
  * Ref has atomic modify support if synchronous, for Effect we need a Semaphore.
- * @tsplus fluent effect/io/Ref modifyWithEffect
  */
 export function modifyWithPermitWithEffect<A>(ref: Ref.Ref<A>, semaphore: Semaphore) {
   const withPermit = semaphore.withPermits(1)
@@ -133,10 +112,6 @@ export function modifyWithPermitWithEffect<A>(ref: Ref.Ref<A>, semaphore: Semaph
     )
 }
 
-/**
- * @tsplus getter Iterable joinAll
- * @tsplus static effect/io/Effect.Ops joinAll
- */
 export function joinAll<E, A>(fibers: Iterable<Fiber.Fiber<A, E>>): Effect.Effect<readonly A[], E> {
   return Fiber.join(Fiber.all(fibers))
 }
@@ -174,9 +149,6 @@ export type LowerServices<T extends Record<string, Context.Tag<any, any> | Effec
   [key in keyof T as LowerFirst<key>]: ServiceA<T[key]>
 }
 
-/**
- * @tsplus static effect/io/Effect.Ops allLower
- */
 export function allLower<T extends Record<string, Context.Tag<any, any> | Effect.Effect<any, any, any>>>(
   services: T
 ) {
@@ -190,9 +162,6 @@ export function allLower<T extends Record<string, Context.Tag<any, any> | Effect
   ) as any as Effect.Effect<LowerServices<T>, ValuesE<T>, ValuesR<T>>
 }
 
-/**
- * @tsplus static effect/io/Effect.Ops allLowerWith
- */
 export function allLowerWith<T extends Record<string, Context.Tag<any, any> | Effect.Effect<any, any, any>>, A>(
   services: T,
   fn: (services: LowerServices<T>) => A
@@ -200,9 +169,6 @@ export function allLowerWith<T extends Record<string, Context.Tag<any, any> | Ef
   return Effect.map(allLower(services), fn)
 }
 
-/**
- * @tsplus static effect/io/Effect.Ops allLowerWithEffect
- */
 export function allLowerWithEffect<
   T extends Record<string, Context.Tag<any, any> | Effect.Effect<any, any, any>>,
   R,
@@ -217,9 +183,6 @@ export function allLowerWithEffect<
 
 /**
  * Recovers from all errors.
- *
- * @tsplus static effect/io/Effect.Ops catchAllMap
- * @tsplus pipeable effect/io/Effect catchAllMap
  */
 export function catchAllMap<E, A2>(f: (e: E) => A2) {
   return <R, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A2 | A, never, R> =>
@@ -228,8 +191,6 @@ export function catchAllMap<E, A2>(f: (e: E) => A2) {
 
 /**
  * Annotates each log in this scope with the specified log annotation.
- *
- * @tsplus static effect/io/Effect.Ops annotateLogscoped
  */
 export function annotateLogscoped(key: string, value: string) {
   return FiberRef
@@ -247,8 +208,6 @@ export function annotateLogscoped(key: string, value: string) {
 
 /**
  * Annotates each log in this scope with the specified log annotations.
- *
- * @tsplus static effect/io/Effect.Ops annotateLogsScoped
  */
 export function annotateLogsScoped(kvps: Record<string, string>) {
   return FiberRef

package/src/NonEmptySetBase.ts

@@ -23,9 +23,6 @@ export interface NonEmptyBrand {
   readonly NonEmpty: unique symbol
 }
 
-/**
- * @tsplus type ets/NESet
- */
 export type NonEmptySet<A> = Set<A> & NonEmptyBrand
 
 function make_<A>(ord: Order.Order<A>, eq_?: Equivalence.Equivalence<A>) {

package/src/Option.ts

@@ -8,29 +8,17 @@ import * as Option from "effect/Option"
 
 export * from "effect/Option"
 
-/**
- * @tsplus getter effect/data/Option value
- */
 export const getOrUndefined = value
 
-/**
- * @tsplus static effect/data/Option.Ops omitableToNullable
- */
 export function omitableToNullable<T>(om: Option.Option<T> | undefined) {
   return om ?? Option.fromNullable(om)
 }
 
-/**
- * @tsplus static effect/data/Option.Ops toBool
- */
 export const toBool = Option.match({
   onNone: () => false,
   onSome: () => true
 })
 
-/**
- * @tsplus static effect/data/Option.Ops fromBool
- */
 export const fromBool = (b: boolean) => (b ? Option.some(true) : Option.none())
 
 /**
@@ -64,7 +52,6 @@ function raisePartial<X>(): X {
 
 /**
  * Simulates a partial function
- * @tsplus static effect/data/Option.Ops partial
  */
 export function partial<ARGS extends any[], A>(
   f: (miss: <X>() => X) => (...args: ARGS) => A

package/src/Pure.ts

@@ -7,9 +7,6 @@ const S1 = Symbol()
 const S2 = Symbol()
 const W = Symbol()
 
-/**
- * @tsplus type PureEnv
- */
 export interface PureState<S, S2 = S> {
   readonly [S1]: (_: S) => void
   readonly [S2]: () => S2
@@ -17,17 +14,11 @@ export interface PureState<S, S2 = S> {
   state: S2
 }
 
-/**
- * @tsplus type PureEnv
- */
 export interface PureLog<W> {
   readonly [W]: () => W
   log: Chunk.Chunk<W>
 }
 
-/**
- * @tsplus type PureEnv
- */
 export interface PureEnv<W, S, S2 = S> extends PureState<S, S2>, PureLog<W> {}
 
 export interface PureEnvTest extends PureState<any>, PureLog<any> {}
@@ -49,9 +40,6 @@ export function makePureEnv<W, S, S2 = S>(s: S2): PureEnv<W, S, S2> {
   return new PureEnvBase<W, S, S2>(s)
 }
 
-/**
- * @tsplus unify PureEnv
- */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function unifyPureEnv<X extends PureEnv<any, any, any>>(
   self: X
@@ -64,16 +52,10 @@ export function unifyPureEnv<X extends PureEnv<any, any, any>>(
   return self
 }
 
-/**
- * @tsplus type Pure
- */
 export type Pure<W, S, S2, R, E, A> = Effect.Effect<A, E, PureEnvEnv<W, S, S2> | R>
 
 // type dsl<W, S, S2> = ProgramDSL<W, S, S2>
 
-/**
- * @tsplus static Pure.Ops GMUA_
- */
 export function GMUA_<W, S, S2, GR, GE, GA, MR, ME, MA, UR, UE, UA>(
   get: Pure<W, S, S2, GR, GE, GA>,
   modify: (i: GA) => Pure<W, S, S2, MR, ME, readonly [GA, MA]>,
@@ -82,9 +64,6 @@ export function GMUA_<W, S, S2, GR, GE, GA, MR, ME, MA, UR, UE, UA>(
   return Effect.flatMap(get, modify).pipe(Effect.flatMap(([s, a]) => Effect.map(update(s), () => a)))
 }
 
-/**
- * @tsplus static Pure.Ops GMUA
- */
 export function GMUA<W, S, S2, GA, MR, ME, MA>(modify: (i: GA) => Pure<W, S, S2, MR, ME, readonly [GA, MA]>) {
   return <GR, GE, UR, UE, UA>(
     get: Pure<W, S, S2, GR, GE, GA>,
@@ -92,10 +71,6 @@ export function GMUA<W, S, S2, GA, MR, ME, MA>(modify: (i: GA) => Pure<W, S, S2,
   ) => GMUA_(get, modify, update)
 }
 
-/**
- * @tsplus static Pure.Ops GMU_
- */
-
 export function GMU_<W, S, S2, GR, GE, GA, MR, ME, UR, UE, UA>(
   get: Pure<W, S, S2, GR, GE, GA>,
   modify: (i: GA) => Pure<W, S, S2, MR, ME, GA>,
@@ -104,9 +79,6 @@ export function GMU_<W, S, S2, GR, GE, GA, MR, ME, UR, UE, UA>(
   return Effect.flatMap(get, modify).pipe(Effect.flatMap(update))
 }
 
-/**
- * @tsplus static Pure.Ops GMU
- */
 export function GMU<W, S, S2, GA, MR, ME>(modify: (i: GA) => Pure<W, S, S2, MR, ME, GA>) {
   return <GR, GE, UR, UE, UA>(
     get: Pure<W, S, S2, GR, GE, GA>,
@@ -124,40 +96,24 @@ export interface PureEnvEnv<W, S, S2> extends Context.ServiceTagged<typeof PureE
   env: PureEnv<W, S, S2>
 }
 
-/**
- * @tsplus static Pure.Ops get
- */
 export function get<S>(): Pure<never, S, S, never, never, S> {
   return Effect.map(castTag<never, S, S>(), (_) => _.env.state)
 }
 
-/**
- * @tsplus static Pure.Ops set
- */
 export function set<S>(s: S): Pure<never, S, S, never, never, void> {
   return Effect.map(castTag<never, S, S>(), (_) => _.env.state = s)
 }
 
 export type PureLogT<W> = Pure<W, unknown, never, never, never, void>
 
-/**
- * @tsplus static Pure.Ops log
- */
 export function log<W>(w: W): PureLogT<W> {
   return Effect.map(castTag<W, unknown, never>(), (_) => _.env.log = Chunk.append(_.env.log, w))
 }
 
-/**
- * @tsplus static Pure.Ops logMany
- */
 export function logMany<W>(w: Iterable<W>): PureLogT<W> {
   return Effect.map(castTag<W, unknown, never>(), (_) => _.env.log = Chunk.appendAll(_.env.log, Chunk.fromIterable(w)))
 }
 
-/**
- * @tsplus static Pure.Ops runAll
- * @tsplus fluent effect/io/Effect runAll
- */
 export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -181,10 +137,6 @@ export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.provide(a, Layer.succeed(tagg, { env: makePureEnv<W3, S3, S4>(s) as any }) as any) as any
 }
 
-/**
- * @tsplus static Pure.Ops runResult
- * @tsplus fluent effect/io/Effect runResult
- */
 export function runResult<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -192,10 +144,6 @@ export function runResult<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Effect.map(r, ([s]) => s)))
 }
 
-/**
- * @tsplus static Pure.Ops runTerm
- * @tsplus fluent effect/io/Effect runTerm
- */
 export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -203,10 +151,6 @@ export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.flatMap(runAll(self, s), ([evts, r]) => Effect.map(r, ([s3, a]) => tuple(s3, Chunk.toArray(evts), a)))
 }
 
-/**
- * @tsplus static Pure.Ops runTermDiscard
- * @tsplus fluent effect/io/Effect runTermDiscard
- */
 export function runTermDiscard<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -214,10 +158,6 @@ export function runTermDiscard<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.map(runTerm(self, s), ([s3, w3]) => tuple(s3, w3))
 }
 
-/**
- * @tsplus static Pure.Ops runA
- * @tsplus fluent effect/io/Effect runA
- */
 export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
@@ -225,9 +165,6 @@ export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
   return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Effect.map(r, ([, a]) => a)))
 }
 
-/**
- * @tsplus static Pure.Ops modifyWith
- */
 export function modify<S2, A, S3>(
   mod: (s: S2) => readonly [S3, A]
 ): Effect.Effect<A, never, { env: PureEnv<never, S2, S3> }> {
@@ -238,9 +175,6 @@ export function modify<S2, A, S3>(
     })) as any
 }
 
-/**
- * @tsplus static Pure.Ops modifyWithEffect
- */
 export function modifyM<W, R, E, A, S2, S3>(
   mod: (s: S2) => Effect.Effect<readonly [S3, A], E, FixEnv<R, W, S2, S3>>
 ): Effect.Effect<A, E, FixEnv<R, W, S2, S3>> {
@@ -251,9 +185,6 @@ export function modifyM<W, R, E, A, S2, S3>(
   ) as any
 }
 
-/**
- * @tsplus static Pure.Ops updateWith
- */
 export function updateWith<S2, S3>(upd: (s: S2) => S3) {
   return modify((_: S2) => {
     const r = upd(_)
@@ -261,9 +192,6 @@ export function updateWith<S2, S3>(upd: (s: S2) => S3) {
   })
 }
 
-/**
- * @tsplus static Pure.Ops updateWithEffect
- */
 export function updateWithEffect<W, R, E, S2, S3>(
   upd: (s: S2, log: (evt: W) => PureLogT<W>) => Effect.Effect<S3, E, FixEnv<R, W, S2, S3>>
 ): Effect.Effect<S3, E, FixEnv<R, W, S2, S3>> {
@@ -278,9 +206,6 @@ export type FixEnv<R, W, S, S2> =
 //   return Effect.accessM((_: PureState<S>) => Ref.get(_.state).map(self))
 // }
 
-// /**
-//  * @tsplus static Pure.Ops getM
-//  */
 // export function getM<W, S, R, E, A>(self: (s: S) => Pure<W, S, R, E, A>): Pure<W, S, R, E, A> {
 //   return Effect.accessM((_: PureState<S>) => Ref.get(_.state).flatMap(self))
 // }
@@ -298,25 +223,6 @@ export type FixEnv<R, W, S, S2> =
 //   return (self: (s: S) => Pure<W, S, R, E, A>) => access(_ => Ref.get(_.state).flatMap(self))
 // }
 
-/**
- * @tsplus type Pure.Ops
- */
-export interface PureOps {
-  // $: PureAspects
-}
-
-// /**
-//  * @tsplus type Pure.Ops
-//  */
-
-// export interface PureAspects {}
-export const Pure: PureOps = {
-  // $: {}
-}
-
-// /**
-//  * @tsplus static Pure.Ops makeDSL
-//  */
 // export function makeProgramDSL<W, S, S2 = S>(): ProgramDSL<W, S, S2> {
 //   return makeDSL_<W,S, S2>()
 // }
@@ -422,35 +328,20 @@ export const Pure: PureOps = {
 
 // type dsl_<W,S, S2 = S> = ReturnType<typeof makeDSL_<W, S, S2>>
 
-// /**
-//  * @tsplus type Pure/DSL
-//  */
 // export interface ProgramDSL<W, S, S2 = S> extends dsl_<W, S, S2> { }
 
-// /**
-//  * @tsplus fluent Pure/DSL modifyWithEffect
-//  */
 // export function dslmodifyM<W, S, R, E, A>(dsl: ProgramDSL<W, S>, mod: (s: S, dsl: ProgramDSL<W, S>) => Effect.Effect<R, E, readonly [S, A]>) {
 //     return dsl.modifyM(_ => mod(_, dsl))
 // }
 
-// /**
-//  * @tsplus fluent Pure/DSL modifyWith
-//  */
 // export function dslmodify<W, S, A>(dsl: ProgramDSL<W, S>, mod: (s: S, dsl: ProgramDSL<W, S>) => readonly [S, A]) {
 //     return dsl.modify(_ => mod(_, dsl))
 // }
 
-// /**
-//  * @tsplus fluent Pure/DSL updateWithEffect
-//  */
 // export function dslupdateM<W, S, R, E, S2, S3>(dsl: ProgramDSL<W, S, S2>, upd: (s: S2, dsl: ProgramDSL<W, S, S2>) => Effect.Effect<R, E, S3>) {
 //     return dsl.updateM(_ => upd(_, dsl))
 // }
 
-// /**
-//  * @tsplus fluent Pure/DSL updateWith
-//  */
 // export function dslupdate<W, S>(dsl: ProgramDSL<W, S>, upd: (s: S, dsl: ProgramDSL<W, S>) => S) {
 //     return dsl.update(_ => upd(_, dsl))
 // }

package/src/Schema/Class.ts

@@ -13,6 +13,14 @@ type _OptionalKeys<O> = {
 
 type FilterOptionalKeys<A> = Omit<A, _OptionalKeys<A>>
 
+type ClassAnnotations<Self, A> =
+  | S.Annotations.Schema<Self>
+  | readonly [
+    S.Annotations.Schema<Self> | undefined,
+    S.Annotations.Schema<Self>?,
+    S.Annotations.Schema<A>?
+  ]
+
 export interface EnhancedClass<Self, Fields extends Struct.Fields, I, R, C, Inherited, Proto>
   extends Schema<Self, I, R>, PropsExtensions<Fields>
 {
@@ -25,76 +33,76 @@ export interface EnhancedClass<Self, Fields extends Struct.Fields, I, R, C, Inhe
 
   readonly fields: Simplify<Fields>
 
-  readonly extend: <Extended = never>(identifier?: string) => <newFields extends Struct.Fields>(
-    newFieldsOr: newFields | HasFields<newFields>,
-    annotations?: S.Annotations.Schema<Extended>
+  readonly extend: <Extended = never>(identifier?: string) => <NewFields extends Struct.Fields>(
+    newFieldsOr: NewFields | HasFields<NewFields>,
+    annotations?: ClassAnnotations<Extended, Struct.Type<Fields & NewFields>>
   ) => [Extended] extends [never] ? MissingSelfGeneric<"Base.extend">
     : EnhancedClass<
       Extended,
-      Fields & newFields,
-      Simplify<I & Struct.Encoded<newFields>>,
-      R | Struct.Context<newFields>,
-      Simplify<C & S.Struct.Constructor<newFields>>,
+      Fields & NewFields,
+      Simplify<I & Struct.Encoded<NewFields>>,
+      R | Struct.Context<NewFields>,
+      Simplify<C & S.Struct.Constructor<NewFields>>,
       Self,
       Proto
     >
 
   readonly transformOrFail: <Transformed = never>(identifier?: string) => <
-    newFields extends Struct.Fields,
+    NewFields extends Struct.Fields,
     R2,
     R3
   >(
-    fields: newFields,
+    fields: NewFields,
     options: {
       readonly decode: (
         input: Types.Simplify<Struct.Type<Fields>>,
         options: ParseOptions,
         ast: AST.Transformation
-      ) => Effect.Effect<Types.Simplify<Struct.Type<Fields & newFields>>, ParseResult.ParseIssue, R2>
+      ) => Effect.Effect<Types.Simplify<Struct.Type<Fields & NewFields>>, ParseResult.ParseIssue, R2>
       readonly encode: (
-        input: Types.Simplify<Struct.Type<Fields & newFields>>,
+        input: Types.Simplify<Struct.Type<Fields & NewFields>>,
         options: ParseOptions,
         ast: AST.Transformation
       ) => Effect.Effect<Struct.Type<Fields>, ParseResult.ParseIssue, R3>
     },
-    annotations?: S.Annotations.Schema<Transformed>
+    annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
   ) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transform">
     : EnhancedClass<
       Transformed,
-      Fields & newFields,
+      Fields & NewFields,
       I,
-      R | Struct.Context<newFields> | R2 | R3,
-      C & Struct.Constructor<newFields>,
+      R | Struct.Context<NewFields> | R2 | R3,
+      C & Struct.Constructor<NewFields>,
       Self,
       Proto
     >
 
   readonly transformOrFailFrom: <Transformed = never>(identifier?: string) => <
-    newFields extends Struct.Fields,
+    NewFields extends Struct.Fields,
     R2,
     R3
   >(
-    fields: newFields,
+    fields: NewFields,
     options: {
       readonly decode: (
         input: Types.Simplify<I>,
         options: ParseOptions,
         ast: AST.Transformation
-      ) => Effect.Effect<Types.Simplify<I & Struct.Encoded<newFields>>, ParseResult.ParseIssue, R2>
+      ) => Effect.Effect<Types.Simplify<I & Struct.Encoded<NewFields>>, ParseResult.ParseIssue, R2>
       readonly encode: (
-        input: Types.Simplify<I & Struct.Encoded<newFields>>,
+        input: Types.Simplify<I & Struct.Encoded<NewFields>>,
         options: ParseOptions,
         ast: AST.Transformation
       ) => Effect.Effect<I, ParseResult.ParseIssue, R3>
     },
-    annotations?: S.Annotations.Schema<Transformed>
+    annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
   ) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transformFrom">
     : EnhancedClass<
       Transformed,
-      Fields & newFields,
+      Fields & NewFields,
       I,
-      R | Struct.Context<newFields> | R2 | R3,
-      Simplify<C & S.Struct.Constructor<newFields>>,
+      R | Struct.Context<NewFields> | R2 | R3,
+      Simplify<C & S.Struct.Constructor<NewFields>>,
       Self,
       Proto
     >
@@ -148,7 +156,7 @@ type HasFields<Fields extends Struct.Fields> = {
 
 export const Class: <Self = never>(identifier?: string) => <Fields extends S.Struct.Fields>(
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: S.Annotations.Schema<Self>
+  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
 ) => [Self] extends [never] ? MissingSelfGeneric<"Class">
   : EnhancedClass<
     Self,
@@ -173,7 +181,7 @@ export const Class: <Self = never>(identifier?: string) => <Fields extends S.Str
 export const TaggedClass: <Self = never>(identifier?: string) => <Tag extends string, Fields extends S.Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: S.Annotations.Schema<Self>
+  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
 ) => [Self] extends [never] ? MissingSelfGeneric<"Class">
   : EnhancedClass<
     Self,
@@ -197,7 +205,7 @@ export const TaggedClass: <Self = never>(identifier?: string) => <Tag extends st
 
 export const ExtendedClass: <Self, SelfFrom>(identifier?: string) => <Fields extends S.Struct.Fields>(
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: S.Annotations.Schema<Self>
+  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
 ) => EnhancedClass<
   Self,
   Fields,
@@ -213,7 +221,7 @@ export const ExtendedTaggedClass: <Self, SelfFrom>(
 ) => <Tag extends string, Fields extends S.Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: S.Annotations.Schema<Self>
+  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
 ) => EnhancedClass<
   Self,
   { readonly _tag: S.tag<Tag> } & Fields,

package/src/Schema/ext.ts

@@ -41,7 +41,8 @@ export declare namespace Struct {
   export type Fields = S.Struct.Fields
   export type Type<F extends Fields> = S.Struct.Type<F>
   export type Encoded<F extends Fields> = S.Struct.Encoded<F>
-  export type Context<F extends Fields> = Schema.Context<F[keyof F]>
+  export type Context<F extends Fields> = S.Struct.Context<F>
+  export type Constructor<F extends Fields> = S.Struct.Constructor<F>
 }
 
 /**
@@ -125,9 +126,6 @@ export const defaultMap = <A, A2, I, R>(s: Schema<ReadonlyMap<A, A2>, I, R>) =>
 export const defaultSet = <A, I, R>(s: Schema<ReadonlySet<A>, I, R>) =>
   s.pipe(withDefaultConstructor(() => new Set<A>()))
 
-/**
- * @tsplus getter effect/schema/Schema withDefaultMake
- */
 export const withDefaultMake = <Self extends S.Schema<any, any, never>>(s: Self) => {
   const a = Object.assign(S.decodeSync(s) as WithDefaults<Self>, s)
   Object.setPrototypeOf(a, s)

package/src/Set.ts

@@ -6,9 +6,6 @@ import { not } from "effect/Predicate"
 import type { Predicate, Refinement } from "./Function.js"
 import { identity, pipe, tuple } from "./Function.js"
 
-/**
- * @tsplus fluent ets/Set find
- */
 export function find_<A, B extends A>(
   as: ReadonlySet<A>,
   refinement: Refinement<A, B>
@@ -18,9 +15,6 @@ export function find_<A>(set: ReadonlySet<A>, predicate: Predicate<A>) {
   return [...set].find(predicate)
 }
 
-/**
- * @tsplus fluent ets/Set findFirst
- */
 export function findFirst_<A, B extends A>(
   set: ReadonlySet<A>,
   refinement: Refinement<A, B>
@@ -30,9 +24,6 @@ export function findFirst_<A>(set: ReadonlySet<A>, predicate: Predicate<A>): Opt
   return Option.fromNullable([...set].find(predicate))
 }
 
-/**
- * @tsplus fluent ets/Set findFirstMap
- */
 export function findFirstMap_<A, B>(
   set: ReadonlySet<A>,
   f: (a: A) => Option.Option<B>
@@ -152,7 +143,6 @@ export function some<A>(predicate: Predicate<A>): (set: Set<A>) => boolean {
 
 /**
  * true if one or more elements match predicate
- * @tsplus fluent ets/Set some
  */
 export function some_<A>(set: Set<A>, predicate: Predicate<A>): boolean {
   return some(predicate)(set)
@@ -256,7 +246,6 @@ export function filter<A>(predicate: Predicate<A>): (set: Set<A>) => Set<A> {
 
 /**
  * Filter set values using predicate
- * @tsplus fluent ets/Set filter
  */
 export function filter_<A, B extends A>(
   set: Set<A>,

package/src/Tag.ts

@@ -1,20 +1,11 @@
-// /**
-//  * @tsplus fluent effect/data/Context/Tag withEffect_
-//  */
 // export function accessM_<T, I, R, E, A>(self: Tag<T, I>, f: (x: T) => Effect<R, E, A>) {
 //   return Effect.serviceWithEffect(self)(f)
 // }
 
 import { Layer } from "effect"
 
-// /**
-//  * @tsplus fluent effect/data/Context/Tag with_
-//  */
 // export function access_<T, I, B>(self: Tag<T, I>, f: (x: T) => B) {
 //   return Effect.serviceWith(self)(f)
 // }
 
-/**
- * @tsplus fluent effect/data/Context/Tag makeLayer
- */
 export const makeLayer = Layer.succeed