effect 3.11.5 → 3.11.7

package/src/Schema.ts

@@ -87,7 +87,7 @@ export interface Schema<in out A, in out I = A, out R = never> extends Schema.Va
    * Merges a set of new annotations with existing ones, potentially overwriting
    * any duplicates.
    */
-  annotations(annotations: Annotations.Schema<A>): Schema<A, I, R>
+  annotations(annotations: Annotations.GenericSchema<A>): Schema<A, I, R>
 }
 
 /**
@@ -107,7 +107,7 @@ export const make = <A, I = A, R = never>(ast: AST.AST): SchemaClass<A, I, R> =>
   static Context: R
   static [TypeId] = variance
   static ast = ast
-  static annotations(annotations: Annotations.Schema<A>) {
+  static annotations(annotations: Annotations.GenericSchema<A>) {
     return make<A, I, R>(mergeSchemaAnnotations(this.ast, annotations))
   }
   static pipe() {
@@ -204,7 +204,7 @@ export declare namespace Annotable {
  * @since 3.10.0
  */
 export interface Annotable<Self extends Schema<A, I, R>, A, I = A, R = never> extends Schema<A, I, R> {
-  annotations(annotations: Annotations.Schema<A>): Self
+  annotations(annotations: Annotations.GenericSchema<A>): Self
 }
 
 /**
@@ -4357,6 +4357,15 @@ export declare namespace Annotations {
     readonly decodingFallback?: AST.DecodingFallbackAnnotation<A>
   }
 
+  /**
+   * @since 3.11.6
+   */
+  export interface GenericSchema<A> extends Schema<A> {
+    readonly arbitrary?: (..._: any) => LazyArbitrary<A>
+    readonly pretty?: (..._: any) => pretty_.Pretty<A>
+    readonly equivalence?: (..._: any) => Equivalence.Equivalence<A>
+  }
+
   /**
    * @since 3.10.0
    */
@@ -4378,7 +4387,7 @@ export const annotations: {
    * @category annotations
    * @since 3.10.0
    */
-  <S extends Annotable.All>(annotations: Annotations.Schema<Schema.Type<S>>): (self: S) => Annotable.Self<S>
+  <S extends Annotable.All>(annotations: Annotations.GenericSchema<Schema.Type<S>>): (self: S) => Annotable.Self<S>
   /**
    * Merges a set of new annotations with existing ones, potentially overwriting
    * any duplicates.
@@ -4386,10 +4395,11 @@ export const annotations: {
    * @category annotations
    * @since 3.10.0
    */
-  <S extends Annotable.All>(self: S, annotations: Annotations.Schema<Schema.Type<S>>): Annotable.Self<S>
+  <S extends Annotable.All>(self: S, annotations: Annotations.GenericSchema<Schema.Type<S>>): Annotable.Self<S>
 } = dual(
   2,
-  <A, I, R>(self: Schema<A, I, R>, annotations: Annotations.Schema<A>): Schema<A, I, R> => self.annotations(annotations)
+  <A, I, R>(self: Schema<A, I, R>, annotations: Annotations.GenericSchema<A>): Schema<A, I, R> =>
+    self.annotations(annotations)
 )
 
 type Rename<A, M> = {
@@ -4562,7 +4572,6 @@ export const pattern = <A extends string>(
         [PatternSchemaId]: { regex },
         description: `a string matching the pattern ${pattern}`,
         jsonSchema: { pattern },
-        arbitrary: () => (fc) => fc.stringMatching(regex) as any,
         ...annotations
       }
     )
@@ -5152,7 +5161,13 @@ export {
  * @category schema id
  * @since 3.10.0
  */
-export const FiniteSchemaId: unique symbol = Symbol.for("effect/SchemaId/Finite")
+export const FiniteSchemaId: unique symbol = filters_.FiniteSchemaId
+
+/**
+ * @category schema id
+ * @since 3.10.0
+ */
+export type FiniteSchemaId = typeof FiniteSchemaId
 
 /**
  * Ensures that the provided value is a finite number.
@@ -5165,9 +5180,10 @@ export const FiniteSchemaId: unique symbol = Symbol.for("effect/SchemaId/Finite"
 export const finite =
   <A extends number>(annotations?: Annotations.Filter<A>) => <I, R>(self: Schema<A, I, R>): filter<Schema<A, I, R>> =>
     self.pipe(
-      filter((a) => Number.isFinite(a), {
+      filter(Number.isFinite, {
         schemaId: FiniteSchemaId,
         description: "a finite number",
+        jsonSchema: { "type": "number" },
         ...annotations
       })
     )
@@ -5387,7 +5403,13 @@ export const between = <A extends number>(
  * @category schema id
  * @since 3.10.0
  */
-export const NonNaNSchemaId: unique symbol = Symbol.for("effect/SchemaId/NonNaN")
+export const NonNaNSchemaId: unique symbol = filters_.NonNaNSchemaId
+
+/**
+ * @category schema id
+ * @since 3.10.0
+ */
+export type NonNaNSchemaId = typeof NonNaNSchemaId
 
 /**
  * @category number filters
@@ -5541,7 +5563,13 @@ export class NonNegative extends Number$.pipe(
  * @category schema id
  * @since 3.10.0
  */
-export const JsonNumberSchemaId: unique symbol = Symbol.for("effect/SchemaId/JsonNumber")
+export const JsonNumberSchemaId: unique symbol = filters_.JsonNumberSchemaId
+
+/**
+ * @category schema id
+ * @since 3.10.0
+ */
+export type JsonNumberSchemaId = typeof JsonNumberSchemaId
 
 /**
  * The `JsonNumber` is a schema for representing JSON numbers. It ensures that the provided value is a valid
@@ -5564,12 +5592,11 @@ export const JsonNumberSchemaId: unique symbol = Symbol.for("effect/SchemaId/Jso
  * @since 3.10.0
  */
 export class JsonNumber extends Number$.pipe(
-  filter(Number.isFinite, {
+  finite({
     schemaId: JsonNumberSchemaId,
     identifier: "JsonNumber",
     title: "JSON-compatible number",
-    description: "a JSON-compatible number, excluding NaN, +Infinity, and -Infinity",
-    jsonSchema: { type: "number" }
+    description: "a JSON-compatible number, excluding NaN, +Infinity, and -Infinity"
   })
 ) {}
 
@@ -6707,8 +6734,8 @@ export class DateFromSelf extends declare(
   {
     identifier: "DateFromSelf",
     description: "a potentially invalid Date instance",
-    pretty: (): pretty_.Pretty<Date> => (date) => `new Date(${JSON.stringify(date)})`,
-    arbitrary: (): LazyArbitrary<Date> => (fc) => fc.date({ noInvalidDate: false }),
+    pretty: () => (date) => `new Date(${JSON.stringify(date)})`,
+    arbitrary: () => (fc) => fc.date({ noInvalidDate: false }),
     equivalence: () => Equivalence.Date
   }
 ) {}
@@ -8343,6 +8370,14 @@ type RequiredKeys<T> = {
   [K in keyof T]-?: {} extends Pick<T, K> ? never : K
 }[keyof T]
 
+type ClassAnnotations<Self, A> =
+  | Annotations.Schema<Self>
+  | readonly [
+    Annotations.Schema<Self> | undefined,
+    Annotations.Schema<Self>?,
+    Annotations.Schema<A>?
+  ]
+
 /**
  * @category api interface
  * @since 3.10.0
@@ -8388,16 +8423,16 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
    * }
    * ```
    */
-  extend<Extended = never>(identifier: string): <newFields extends Struct.Fields>(
-    fields: newFields | HasFields<newFields>,
-    annotations?: Annotations.Schema<Extended>
+  extend<Extended = never>(identifier: string): <NewFields extends Struct.Fields>(
+    fields: NewFields | HasFields<NewFields>,
+    annotations?: ClassAnnotations<Extended, Struct.Type<Fields & NewFields>>
   ) => [Extended] extends [never] ? MissingSelfGeneric<"Base.extend">
     : Class<
       Extended,
-      Fields & newFields,
-      I & Struct.Encoded<newFields>,
-      R | Struct.Context<newFields>,
-      C & Struct.Constructor<newFields>,
+      Fields & NewFields,
+      I & Struct.Encoded<NewFields>,
+      R | Struct.Context<NewFields>,
+      C & Struct.Constructor<NewFields>,
       Self,
       Proto
     >
@@ -8432,31 +8467,31 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
    * ```
    */
   transformOrFail<Transformed = never>(identifier: string): <
-    newFields extends Struct.Fields,
+    NewFields extends Struct.Fields,
     R2,
     R3
   >(
-    fields: newFields,
+    fields: NewFields,
     options: {
       readonly decode: (
         input: Simplify<Struct.Type<Fields>>,
         options: ParseOptions,
         ast: AST.Transformation
-      ) => Effect.Effect<Simplify<Struct.Type<Fields & newFields>>, ParseResult.ParseIssue, R2>
+      ) => Effect.Effect<Simplify<Struct.Type<Fields & NewFields>>, ParseResult.ParseIssue, R2>
       readonly encode: (
-        input: Simplify<Struct.Type<Fields & newFields>>,
+        input: Simplify<Struct.Type<Fields & NewFields>>,
         options: ParseOptions,
         ast: AST.Transformation
       ) => Effect.Effect<Struct.Type<Fields>, ParseResult.ParseIssue, R3>
     },
-    annotations?: Annotations.Schema<Transformed>
+    annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
   ) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transformOrFail">
     : Class<
       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
     >
@@ -8491,31 +8526,31 @@ export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, P
    * ```
    */
   transformOrFailFrom<Transformed = never>(identifier: string): <
-    newFields extends Struct.Fields,
+    NewFields extends Struct.Fields,
     R2,
     R3
   >(
-    fields: newFields,
+    fields: NewFields,
     options: {
       readonly decode: (
         input: Simplify<I>,
         options: ParseOptions,
         ast: AST.Transformation
-      ) => Effect.Effect<Simplify<I & Struct.Encoded<newFields>>, ParseResult.ParseIssue, R2>
+      ) => Effect.Effect<Simplify<I & Struct.Encoded<NewFields>>, ParseResult.ParseIssue, R2>
       readonly encode: (
-        input: Simplify<I & Struct.Encoded<newFields>>,
+        input: Simplify<I & Struct.Encoded<NewFields>>,
         options: ParseOptions,
         ast: AST.Transformation
       ) => Effect.Effect<I, ParseResult.ParseIssue, R3>
     },
-    annotations?: Annotations.Schema<Transformed>
+    annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
   ) => [Transformed] extends [never] ? MissingSelfGeneric<"Base.transformOrFailFrom">
     : Class<
       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
     >
@@ -8559,7 +8594,7 @@ const getFieldsFromFieldsOr = <Fields extends Struct.Fields>(fieldsOr: Fields |
 export const Class = <Self = never>(identifier: string) =>
 <Fields extends Struct.Fields>(
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: Annotations.Schema<Self>
+  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
 ): [Self] extends [never] ? MissingSelfGeneric<"Class">
   : Class<
     Self,
@@ -8618,7 +8653,7 @@ export const TaggedClass = <Self = never>(identifier?: string) =>
 <Tag extends string, Fields extends Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: Annotations.Schema<Self>
+  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
 ): [Self] extends [never] ? MissingSelfGeneric<"TaggedClass", `"Tag", `>
   : TaggedClass<Self, Tag, { readonly _tag: tag<Tag> } & Fields> =>
 {
@@ -8681,7 +8716,7 @@ export const TaggedError = <Self = never>(identifier?: string) =>
 <Tag extends string, Fields extends Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: Annotations.Schema<Self>
+  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
 ): [Self] extends [never] ? MissingSelfGeneric<"TaggedError", `"Tag", `>
   : TaggedErrorClass<
     Self,
@@ -8734,23 +8769,61 @@ const getDisableValidationMakeOption = (options: MakeOptions | undefined): boole
 
 const astCache = globalValue("effect/Schema/astCache", () => new WeakMap<any, AST.AST>())
 
-const makeClass = ({ Base, annotations, disableToString, fields, identifier, kind, schema }: {
-  kind: "Class" | "TaggedClass" | "TaggedError" | "TaggedRequest"
-  identifier: string
-  schema: Schema.Any
-  fields: Struct.Fields
-  Base: new(...args: ReadonlyArray<any>) => any
-  annotations?: Annotations.Schema<any> | undefined
-  disableToString?: boolean | undefined
-}): any => {
+const getClassAnnotations = <Self, A>(
+  annotations: ClassAnnotations<Self, A> | undefined
+): [Annotations.Schema<Self>?, Annotations.Schema<Self>?, Annotations.Schema<A>?] => {
+  if (annotations === undefined) {
+    return []
+  } else if (Array.isArray(annotations)) {
+    return annotations as any
+  } else {
+    return [annotations] as any
+  }
+}
+
+const makeClass = <Fields extends Struct.Fields>(
+  { Base, annotations, disableToString, fields, identifier, kind, schema }: {
+    kind: "Class" | "TaggedClass" | "TaggedError" | "TaggedRequest"
+    identifier: string
+    schema: Schema.Any
+    fields: Fields
+    Base: new(...args: ReadonlyArray<any>) => any
+    annotations?: ClassAnnotations<any, any> | undefined
+    disableToString?: boolean | undefined
+  }
+): any => {
   const classSymbol = Symbol.for(`effect/Schema/${kind}/${identifier}`)
 
-  const ts = typeSchema(schema)
-  const declarationSurrogate = ts.annotations({ identifier, ...annotations })
-  const typeSide = ts.annotations({ [AST.AutoTitleAnnotationId]: `${identifier} (Type side)` })
-  const transformationSurrogate = schema.annotations({ ...annotations })
-  const validateSchema = schema.annotations({ [AST.AutoTitleAnnotationId]: `${identifier} (Constructor)` })
-  const encodedSide = schema.annotations({ [AST.AutoTitleAnnotationId]: `${identifier} (Encoded side)` })
+  const [typeAnnotations, transformationAnnotations, encodedAnnotations] = getClassAnnotations(annotations)
+
+  const typeSchema_ = typeSchema(schema)
+
+  const declarationSurrogate = typeSchema_.annotations({
+    identifier,
+    ...typeAnnotations
+  })
+
+  const typeSide = typeSchema_.annotations({
+    [AST.AutoTitleAnnotationId]: `${identifier} (Type side)`,
+    ...typeAnnotations
+  })
+
+  const constructorSchema = schema.annotations({
+    [AST.AutoTitleAnnotationId]: `${identifier} (Constructor)`,
+    ...typeAnnotations
+  })
+
+  const encodedSide = schema.annotations({
+    [AST.AutoTitleAnnotationId]: `${identifier} (Encoded side)`,
+    ...encodedAnnotations
+  })
+
+  const transformationSurrogate = schema.annotations({
+    [AST.JSONIdentifierAnnotationId]: identifier,
+    ...encodedAnnotations,
+    ...typeAnnotations,
+    ...transformationAnnotations
+  })
 
   const fallbackInstanceOf = (u: unknown) => Predicate.hasProperty(u, classSymbol) && ParseResult.is(typeSide)(u)
 
@@ -8765,7 +8838,7 @@ const makeClass = ({ Base, annotations, disableToString, fields, identifier, kin
       }
       props = lazilyMergeDefaults(fields, props)
       if (!getDisableValidationMakeOption(options)) {
-        props = ParseResult.validateSync(validateSchema)(props)
+        props = ParseResult.validateSync(constructorSchema)(props)
       }
       super(props, true)
     }
@@ -8777,8 +8850,9 @@ const makeClass = ({ Base, annotations, disableToString, fields, identifier, kin
     static [TypeId] = variance
 
     static get ast(): AST.AST {
-      if (astCache.has(this)) {
-        return astCache.get(this)!
+      let out = astCache.get(this)
+      if (out) {
+        return out
       }
 
       const declaration: Schema.Any = declare(
@@ -8803,20 +8877,22 @@ const makeClass = ({ Base, annotations, disableToString, fields, identifier, kin
           arbitrary: (arb) => (fc) => arb(fc).map((props) => new this(props)),
           equivalence: identity,
           [AST.SurrogateAnnotationId]: declarationSurrogate.ast,
-          ...annotations
+          ...typeAnnotations
         }
       )
 
-      const transformation = transform(
+      out = transform(
         encodedSide,
         declaration,
         { strict: true, decode: (input) => new this(input, true), encode: identity }
       ).annotations({
-        [AST.JSONIdentifierAnnotationId]: identifier,
-        [AST.SurrogateAnnotationId]: transformationSurrogate.ast
-      })
-      astCache.set(this, transformation.ast)
-      return transformation.ast
+        [AST.SurrogateAnnotationId]: transformationSurrogate.ast,
+        ...transformationAnnotations
+      }).ast
+
+      astCache.set(this, out)
+
+      return out
     }
 
     static pipe() {
@@ -8843,8 +8919,11 @@ const makeClass = ({ Base, annotations, disableToString, fields, identifier, kin
 
     static identifier = identifier
 
-    static extend<Extended>(identifier: string) {
-      return (newFieldsOr: Struct.Fields | HasFields<Struct.Fields>, annotations?: Annotations.Schema<Extended>) => {
+    static extend<Extended, NewFields extends Struct.Fields>(identifier: string) {
+      return (
+        newFieldsOr: NewFields | HasFields<NewFields>,
+        annotations?: ClassAnnotations<Extended, Struct.Type<Fields & NewFields>>
+      ) => {
         const newFields = getFieldsFromFieldsOr(newFieldsOr)
         const newSchema = getSchemaFromFieldsOr(newFieldsOr)
         const extendedFields = extendFields(fields, newFields)
@@ -8859,9 +8938,13 @@ const makeClass = ({ Base, annotations, disableToString, fields, identifier, kin
       }
     }
 
-    static transformOrFail<Transformed>(identifier: string) {
-      return (newFields: Struct.Fields, options: any, annotations?: Annotations.Schema<Transformed>) => {
-        const transformedFields: Struct.Fields = extendFields(fields, newFields)
+    static transformOrFail<Transformed, NewFields extends Struct.Fields>(identifier: string) {
+      return (
+        newFieldsOr: NewFields,
+        options: any,
+        annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
+      ) => {
+        const transformedFields: Struct.Fields = extendFields(fields, newFieldsOr)
         return makeClass({
           kind,
           identifier,
@@ -8877,8 +8960,12 @@ const makeClass = ({ Base, annotations, disableToString, fields, identifier, kin
       }
     }
 
-    static transformOrFailFrom<Transformed>(identifier: string) {
-      return (newFields: Struct.Fields, options: any, annotations?: Annotations.Schema<Transformed>) => {
+    static transformOrFailFrom<Transformed, NewFields extends Struct.Fields>(identifier: string) {
+      return (
+        newFields: NewFields,
+        options: any,
+        annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
+      ) => {
         const transformedFields: Struct.Fields = extendFields(fields, newFields)
         return makeClass({
           kind,

package/src/internal/schema/filters.ts

@@ -2,85 +2,100 @@ import type * as Schema from "../../Schema.js"
 
 /** @internal */
 export const GreaterThanSchemaId: Schema.GreaterThanSchemaId = Symbol.for(
-  "effect/schema/GreaterThan"
+  "effect/SchemaId/GreaterThan"
 ) as Schema.GreaterThanSchemaId
 
 /** @internal */
 export const GreaterThanOrEqualToSchemaId: Schema.GreaterThanOrEqualToSchemaId = Symbol.for(
-  "effect/schema/GreaterThanOrEqualTo"
+  "effect/SchemaId/GreaterThanOrEqualTo"
 ) as Schema.GreaterThanOrEqualToSchemaId
 
 /** @internal */
 export const LessThanSchemaId: Schema.LessThanSchemaId = Symbol.for(
-  "effect/schema/LessThan"
+  "effect/SchemaId/LessThan"
 ) as Schema.LessThanSchemaId
 
 /** @internal */
 export const LessThanOrEqualToSchemaId: Schema.LessThanOrEqualToSchemaId = Symbol.for(
-  "effect/schema/LessThanOrEqualTo"
+  "effect/SchemaId/LessThanOrEqualTo"
 ) as Schema.LessThanOrEqualToSchemaId
 
 /** @internal */
 export const IntSchemaId: Schema.IntSchemaId = Symbol.for(
-  "effect/schema/Int"
+  "effect/SchemaId/Int"
 ) as Schema.IntSchemaId
 
+/** @internal */
+export const NonNaNSchemaId: Schema.NonNaNSchemaId = Symbol.for(
+  "effect/SchemaId/NonNaN"
+) as Schema.NonNaNSchemaId
+
+/** @internal */
+export const FiniteSchemaId: Schema.FiniteSchemaId = Symbol.for(
+  "effect/SchemaId/Finite"
+) as Schema.FiniteSchemaId
+
+/** @internal */
+export const JsonNumberSchemaId: Schema.JsonNumberSchemaId = Symbol.for(
+  "effect/SchemaId/JsonNumber"
+) as Schema.JsonNumberSchemaId
+
 /** @internal */
 export const BetweenSchemaId: Schema.BetweenSchemaId = Symbol.for(
-  "effect/schema/Between"
+  "effect/SchemaId/Between"
 ) as Schema.BetweenSchemaId
 
 /** @internal */
 export const GreaterThanBigintSchemaId: Schema.GreaterThanBigIntSchemaId = Symbol.for(
-  "effect/schema/GreaterThanBigint"
+  "effect/SchemaId/GreaterThanBigint"
 ) as Schema.GreaterThanBigIntSchemaId
 
 /** @internal */
 export const GreaterThanOrEqualToBigIntSchemaId: Schema.GreaterThanOrEqualToBigIntSchemaId = Symbol.for(
-  "effect/schema/GreaterThanOrEqualToBigint"
+  "effect/SchemaId/GreaterThanOrEqualToBigint"
 ) as Schema.GreaterThanOrEqualToBigIntSchemaId
 
 /** @internal */
 export const LessThanBigIntSchemaId: Schema.LessThanBigIntSchemaId = Symbol.for(
-  "effect/schema/LessThanBigint"
+  "effect/SchemaId/LessThanBigint"
 ) as Schema.LessThanBigIntSchemaId
 
 /** @internal */
 export const LessThanOrEqualToBigIntSchemaId: Schema.LessThanOrEqualToBigIntSchemaId = Symbol.for(
-  "effect/schema/LessThanOrEqualToBigint"
+  "effect/SchemaId/LessThanOrEqualToBigint"
 ) as Schema.LessThanOrEqualToBigIntSchemaId
 
 /** @internal */
 export const BetweenBigintSchemaId: Schema.BetweenBigIntSchemaId = Symbol.for(
-  "effect/schema/BetweenBigint"
+  "effect/SchemaId/BetweenBigint"
 ) as Schema.BetweenBigIntSchemaId
 
 /** @internal */
 export const MinLengthSchemaId: Schema.MinLengthSchemaId = Symbol.for(
-  "effect/schema/MinLength"
+  "effect/SchemaId/MinLength"
 ) as Schema.MinLengthSchemaId
 
 /** @internal */
 export const MaxLengthSchemaId: Schema.MaxLengthSchemaId = Symbol.for(
-  "effect/schema/MaxLength"
+  "effect/SchemaId/MaxLength"
 ) as Schema.MaxLengthSchemaId
 
 /** @internal */
 export const LengthSchemaId: Schema.LengthSchemaId = Symbol.for(
-  "effect/schema/Length"
+  "effect/SchemaId/Length"
 ) as Schema.LengthSchemaId
 
 /** @internal */
 export const MinItemsSchemaId: Schema.MinItemsSchemaId = Symbol.for(
-  "effect/schema/MinItems"
+  "effect/SchemaId/MinItems"
 ) as Schema.MinItemsSchemaId
 
 /** @internal */
 export const MaxItemsSchemaId: Schema.MaxItemsSchemaId = Symbol.for(
-  "effect/schema/MaxItems"
+  "effect/SchemaId/MaxItems"
 ) as Schema.MaxItemsSchemaId
 
 /** @internal */
 export const ItemsCountSchemaId: Schema.ItemsCountSchemaId = Symbol.for(
-  "effect/schema/ItemsCount"
+  "effect/SchemaId/ItemsCount"
 ) as Schema.ItemsCountSchemaId

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.11.5"
+let moduleVersion = "3.11.7"
 
 export const getCurrentVersion = () => moduleVersion