effect 4.0.0-beta.74 → 4.0.0-beta.75

package/src/internal/schema/arbitrary.ts

@@ -6,17 +6,17 @@ import * as Number from "../../Number.ts"
 import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import type * as Schema from "../../Schema.ts"
-import * as AST from "../../SchemaAST.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
 import * as Struct from "../../Struct.ts"
 import type * as FastCheck from "../../testing/FastCheck.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
 import { errorWithPath } from "../errors.ts"
 import * as InternalAnnotations from "./annotations.ts"
 
-const arbitraryMemoMap = new WeakMap<AST.AST, LazyArbitraryWithContext<any>>()
+const arbitraryMemoMap = new WeakMap<SchemaAST.AST, LazyArbitraryWithContext<any>>()
 
-function applyChecks(ast: AST.AST, filters: Array<AST.Filter<any>>, arbitrary: FastCheck.Arbitrary<any>) {
-  return filters.map((filter) => (a: any) => filter.run(a, ast, AST.defaultParseOptions) === undefined).reduce(
+function applyChecks(ast: SchemaAST.AST, filters: Array<SchemaAST.Filter<any>>, arbitrary: FastCheck.Arbitrary<any>) {
+  return filters.map((filter) => (a: any) => filter.run(a, ast, SchemaAST.defaultParseOptions) === undefined).reduce(
     (acc, filter) => acc.filter(filter),
     arbitrary
   )
@@ -99,7 +99,7 @@ function isConstraintKey(key: string): key is keyof Schema.Annotations.ToArbitra
 
 /** @internal */
 export function constraintContext(
-  filters: Array<AST.Filter<any>>
+  filters: Array<SchemaAST.Filter<any>>
 ): (ctx: Schema.Annotations.ToArbitrary.Context) => Schema.Annotations.ToArbitrary.Context {
   const annotations = filters.map((filter) => filter.annotations?.toArbitraryConstraint).filter(
     Predicate.isNotUndefined
@@ -140,7 +140,7 @@ interface LazyArbitraryWithContext<T> {
 }
 
 /** @internal */
-export function getFilters(checks: AST.Checks | undefined): Array<AST.Filter<any>> {
+export function getFilters(checks: SchemaAST.Checks | undefined): Array<SchemaAST.Filter<any>> {
   if (checks) {
     return checks.flatMap((check) => {
       switch (check._tag) {
@@ -155,11 +155,11 @@ export function getFilters(checks: AST.Checks | undefined): Array<AST.Filter<any
 }
 
 /** @internal */
-export const memoized = memoize((ast: AST.AST): LazyArbitraryWithContext<any> => {
+export const memoized = memoize((ast: SchemaAST.AST): LazyArbitraryWithContext<any> => {
   return recur(ast, [])
 })
 
-function recur(ast: AST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWithContext<any> {
+function recur(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWithContext<any> {
   // ---------------------------------------------
   // handle Override annotation
   // ---------------------------------------------
@@ -167,7 +167,7 @@ function recur(ast: AST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWit
     | Schema.Annotations.ToArbitrary.Declaration<any, ReadonlyArray<Schema.Top>>
     | undefined
   if (annotation) {
-    const typeParameters = AST.isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path)) : []
+    const typeParameters = SchemaAST.isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path)) : []
     const filters = getFilters(ast.checks)
     const f = constraintContext(filters)
     return (fc, ctx) =>
@@ -180,13 +180,13 @@ function recur(ast: AST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWit
   if (ast.checks) {
     const filters = getFilters(ast.checks)
     const f = constraintContext(filters)
-    const lawc = recur(AST.replaceChecks(ast, undefined), path)
+    const lawc = recur(SchemaAST.replaceChecks(ast, undefined), path)
     return (fc, ctx) => applyChecks(ast, filters, lawc(fc, f(ctx)))
   }
   return base(ast, path)
 }
 
-function base(ast: AST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWithContext<any> {
+function base(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWithContext<any> {
   switch (ast._tag) {
     case "Never":
     case "Declaration":
@@ -229,9 +229,9 @@ function base(ast: AST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWith
     case "ObjectKeyword":
       return (fc) => fc.oneof(fc.object(), fc.array(fc.anything()))
     case "Enum":
-      return recur(AST.enumsToLiterals(ast), path)
+      return recur(SchemaAST.enumsToLiterals(ast), path)
     case "TemplateLiteral":
-      return (fc) => fc.stringMatching(AST.getTemplateLiteralRegExp(ast))
+      return (fc) => fc.stringMatching(SchemaAST.getTemplateLiteralRegExp(ast))
     case "Arrays":
       return (fc, ctx) => {
         const reset = resetContext(ctx)
@@ -240,7 +240,7 @@ function base(ast: AST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWith
         // ---------------------------------------------
         const elements: Array<FastCheck.Arbitrary<Option.Option<any>>> = ast.elements.map((e, i) => {
           const out = recur(e, [...path, i])(fc, reset)
-          if (!AST.isOptional(e)) {
+          if (!SchemaAST.isOptional(e)) {
             return out.map(Option.some)
           }
           return out.chain((a) => fc.boolean().map((b) => b ? Option.some(a) : Option.none()))
@@ -285,7 +285,7 @@ function base(ast: AST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWith
         const requiredKeys: Array<PropertyKey> = []
         for (const ps of ast.propertySignatures) {
           const name = ps.name
-          if (!AST.isOptional(ps.type)) {
+          if (!SchemaAST.isOptional(ps.type)) {
             requiredKeys.push(name)
           }
           pss[name] = recur(ps.type, [...path, name])(fc, reset)
@@ -315,7 +315,7 @@ function base(ast: AST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitraryWith
 
       if (memo) return memo
 
-      const get = AST.memoizeThunk(() => recur(ast.thunk(), path))
+      const get = SchemaAST.memoizeThunk(() => recur(ast.thunk(), path))
       const out: LazyArbitraryWithContext<any> = (fc, ctx) =>
         fc.constant(null).chain(() => get()(fc, { ...ctx, isSuspend: true }))
 

package/src/internal/schema/equivalence.ts

@@ -3,17 +3,17 @@ import * as Equivalence from "../../Equivalence.ts"
 import { memoize } from "../../Function.ts"
 import * as Predicate from "../../Predicate.ts"
 import type * as Schema from "../../Schema.ts"
-import * as AST from "../../SchemaAST.ts"
-import * as Parser from "../../SchemaParser.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
 import { errorWithPath } from "../errors.ts"
 import * as InternalAnnotations from "./annotations.ts"
 
 /** @internal */
-export const toEquivalence = memoize((ast: AST.AST): Equivalence.Equivalence<any> => {
+export const toEquivalence = memoize((ast: SchemaAST.AST): Equivalence.Equivalence<any> => {
   return recur(ast, [])
 })
 
-function recur(ast: AST.AST, path: ReadonlyArray<PropertyKey>): Equivalence.Equivalence<any> {
+function recur(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): Equivalence.Equivalence<any> {
   // ---------------------------------------------
   // handle annotations
   // ---------------------------------------------
@@ -21,7 +21,7 @@ function recur(ast: AST.AST, path: ReadonlyArray<PropertyKey>): Equivalence.Equi
     | Schema.Annotations.ToEquivalence.Declaration<any, ReadonlyArray<any>>
     | undefined
   if (annotation) {
-    return annotation(AST.isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path)) : [])
+    return annotation(SchemaAST.isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path)) : [])
   }
   switch (ast._tag) {
     case "Never":
@@ -105,7 +105,7 @@ function recur(ast: AST.AST, path: ReadonlyArray<PropertyKey>): Equivalence.Equi
           const name = ps.name
           const aHas = Object.hasOwn(a, name)
           const bHas = Object.hasOwn(b, name)
-          if (AST.isOptional(ps.type)) {
+          if (SchemaAST.isOptional(ps.type)) {
             if (aHas !== bHas) {
               return false
             }
@@ -119,8 +119,8 @@ function recur(ast: AST.AST, path: ReadonlyArray<PropertyKey>): Equivalence.Equi
         // ---------------------------------------------
         for (let i = 0; i < indexSignatures.length; i++) {
           const is = ast.indexSignatures[i]
-          const aKeys = AST.getIndexSignatureKeys(a, is.parameter)
-          const bKeys = AST.getIndexSignatureKeys(b, is.parameter)
+          const aKeys = SchemaAST.getIndexSignatureKeys(a, is.parameter)
+          const bKeys = SchemaAST.getIndexSignatureKeys(b, is.parameter)
 
           if (aKeys.length !== bKeys.length) return false
 
@@ -136,8 +136,8 @@ function recur(ast: AST.AST, path: ReadonlyArray<PropertyKey>): Equivalence.Equi
     }
     case "Union":
       return Equivalence.make((a, b) => {
-        const candidates = AST.getCandidates(a, ast.types)
-        const types = candidates.map(Parser._is)
+        const candidates = SchemaAST.getCandidates(a, ast.types)
+        const types = candidates.map(SchemaParser._is)
         for (let i = 0; i < candidates.length; i++) {
           const is = types[i]
           if (is(a) && is(b)) {
@@ -147,7 +147,7 @@ function recur(ast: AST.AST, path: ReadonlyArray<PropertyKey>): Equivalence.Equi
         return false
       })
     case "Suspend": {
-      const get = AST.memoizeThunk(() => recur(ast.thunk(), path))
+      const get = SchemaAST.memoizeThunk(() => recur(ast.thunk(), path))
       return Equivalence.make((a, b) => get()(a, b))
     }
   }

package/src/internal/schema/representation.ts

@@ -7,24 +7,24 @@ import * as Predicate from "../../Predicate.ts"
 import * as Rec from "../../Record.ts"
 import * as RegEx from "../../RegExp.ts"
 import type * as Schema from "../../Schema.ts"
-import * as AST from "../../SchemaAST.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import * as InternalAnnotations from "./annotations.ts"
 import * as InternalSchema from "./schema.ts"
 
 /** @internal */
-export function fromAST(ast: AST.AST): SchemaRepresentation.Document {
+export function fromAST(ast: SchemaAST.AST): SchemaRepresentation.Document {
   const { references, representations: schemas } = fromASTs([ast])
   return { representation: schemas[0], references }
 }
 
 /** @internal */
-export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRepresentation.MultiDocument {
+export function fromASTs(asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]): SchemaRepresentation.MultiDocument {
   const references: Record<string, SchemaRepresentation.Representation> = {}
 
-  const referenceMap = new Map<AST.AST, string>()
+  const referenceMap = new Map<SchemaAST.AST, string>()
   const uniqueReferences = new Set<string>()
-  const visiting = new Set<AST.AST>()
+  const visiting = new Set<SchemaAST.AST>()
 
   const schemas = Arr.map(asts, (ast) => recur(ast))
 
@@ -45,13 +45,13 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
     return candidate
   }
 
-  function recur(ast: AST.AST, prefix?: string): SchemaRepresentation.Representation {
+  function recur(ast: SchemaAST.AST, prefix?: string): SchemaRepresentation.Representation {
     const found = referenceMap.get(ast)
     if (found !== undefined) {
       return { _tag: "Reference", $ref: found }
     }
 
-    const last = AST.getLastEncoding(ast)
+    const last = SchemaAST.getLastEncoding(ast)
     const identifier = InternalAnnotations.resolveIdentifier(ast) ?? prefix
 
     if (ast !== last) {
@@ -95,17 +95,17 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
     return out
   }
 
-  function getEncodedSchema(last: AST.Declaration): AST.AST {
+  function getEncodedSchema(last: SchemaAST.Declaration): SchemaAST.AST {
     const getLink = last.annotations?.toCodecJson ?? last.annotations?.toCodec
     if (Predicate.isFunction(getLink)) {
-      const tps = last.typeParameters.map((tp) => InternalSchema.make(AST.toEncoded(tp)))
+      const tps = last.typeParameters.map((tp) => InternalSchema.make(SchemaAST.toEncoded(tp)))
       const link = getLink(tps)
-      return AST.replaceEncoding(last, [link])
+      return SchemaAST.replaceEncoding(last, [link])
     }
-    return AST.null
+    return SchemaAST.null
   }
 
-  function on(last: AST.AST): SchemaRepresentation.Representation {
+  function on(last: SchemaAST.AST): SchemaRepresentation.Representation {
     const annotations = fromASTAnnotations(last.annotations)
     switch (last._tag) {
       case "Declaration": {
@@ -135,7 +135,7 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
           _tag: last._tag,
           checks: fromASTChecks(last.checks),
           ...annotations,
-          ...(typeof contentMediaType === "string" && AST.isAST(contentSchema)
+          ...(typeof contentMediaType === "string" && SchemaAST.isAST(contentSchema)
             ? { contentSchema: recur(contentSchema) }
             : undefined)
         }
@@ -180,9 +180,9 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
         return {
           _tag: last._tag,
           elements: last.elements.map((e) => {
-            const last = AST.getLastEncoding(e)
+            const last = SchemaAST.getLastEncoding(e)
             return {
-              isOptional: AST.isOptional(last),
+              isOptional: SchemaAST.isOptional(last),
               type: recur(e),
               ...fromASTAnnotations(last.context?.annotations)
             }
@@ -195,12 +195,12 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
         return {
           _tag: last._tag,
           propertySignatures: last.propertySignatures.map((ps) => {
-            const last = AST.getLastEncoding(ps.type)
+            const last = SchemaAST.getLastEncoding(ps.type)
             return {
               name: ps.name,
               type: recur(ps.type),
-              isOptional: AST.isOptional(last),
-              isMutable: AST.isMutable(last),
+              isOptional: SchemaAST.isOptional(last),
+              isMutable: SchemaAST.isMutable(last),
               ...fromASTAnnotations(last.context?.annotations)
             }
           }),
@@ -232,12 +232,12 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
   }
 
   function fromASTChecks(
-    checks: readonly [AST.Check<any>, ...Array<AST.Check<any>>] | undefined
+    checks: readonly [SchemaAST.Check<any>, ...Array<SchemaAST.Check<any>>] | undefined
   ): Array<SchemaRepresentation.Check<any>> {
     if (!checks) return []
     return checks.map(getCheck).filter((c) => c !== undefined)
 
-    function getCheck(c: AST.Check<any>): SchemaRepresentation.Check<any> | undefined {
+    function getCheck(c: SchemaAST.Check<any>): SchemaRepresentation.Check<any> | undefined {
       switch (c._tag) {
         case "Filter": {
           const meta = c.annotations?.meta
@@ -283,7 +283,7 @@ export const fromASTBlacklist: Set<string> = new Set([
   "toCodec",
   "toCodecJson",
   "toCodecIso",
-  AST.ClassTypeId
+  SchemaAST.ClassTypeId
 ])
 
 const standardJsonSchemaAnnotationKeys: ReadonlySet<string> = new Set([
@@ -784,9 +784,9 @@ function getPartPattern(part: SchemaRepresentation.Representation): string {
     case "Literal":
       return RegEx.escape(globalThis.String(part.literal))
     case "String":
-      return AST.STRING_PATTERN
+      return SchemaAST.STRING_PATTERN
     case "Number":
-      return AST.FINITE_PATTERN
+      return SchemaAST.FINITE_PATTERN
     case "TemplateLiteral":
       return part.parts.map(getPartPattern).join("")
     case "Union":

package/src/internal/schema/schema.ts

@@ -2,9 +2,9 @@ import * as Effect from "../../Effect.ts"
 import { flow } from "../../Function.ts"
 import * as Pipeable from "../../Pipeable.ts"
 import type * as Schema from "../../Schema.ts"
-import * as AST from "../../SchemaAST.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
 import type { Issue } from "../../SchemaIssue.ts"
-import * as Parser from "../../SchemaParser.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
 
 /** @internal */
 export const TypeId = "~effect/Schema/Schema"
@@ -15,13 +15,13 @@ const SchemaProto = {
     return Pipeable.pipeArguments(this, arguments)
   },
   annotate(this: Schema.Top, annotations: Schema.Annotations.Annotations) {
-    return this.rebuild(AST.annotate(this.ast, annotations))
+    return this.rebuild(SchemaAST.annotate(this.ast, annotations))
   },
   annotateKey(this: Schema.Top, annotations: Schema.Annotations.Key<unknown>) {
-    return this.rebuild(AST.annotateKey(this.ast, annotations))
+    return this.rebuild(SchemaAST.annotateKey(this.ast, annotations))
   },
-  check(this: Schema.Top, ...checks: readonly [AST.Check<unknown>, ...Array<AST.Check<unknown>>]) {
-    return this.rebuild(AST.appendChecks(this.ast, checks))
+  check(this: Schema.Top, ...checks: readonly [SchemaAST.Check<unknown>, ...Array<SchemaAST.Check<unknown>>]) {
+    return this.rebuild(SchemaAST.appendChecks(this.ast, checks))
   }
 }
 
@@ -32,10 +32,10 @@ export function make<S extends Schema.Top>(ast: S["ast"], options?: object): S {
     Object.assign(self, options)
   }
   self.ast = ast
-  self.rebuild = (ast: AST.AST) => make(ast, options)
-  self.makeEffect = flow(Parser.makeEffect(self), Effect.mapErrorEager((issue) => new SchemaError(issue)))
-  self.make = Parser.make(self)
-  self.makeOption = Parser.makeOption(self)
+  self.rebuild = (ast: SchemaAST.AST) => make(ast, options)
+  self.makeEffect = flow(SchemaParser.makeEffect(self), Effect.mapErrorEager((issue) => new SchemaError(issue)))
+  self.make = SchemaParser.make(self)
+  self.makeOption = SchemaParser.makeOption(self)
   return self
 }
 
@@ -62,7 +62,7 @@ export class SchemaError {
 /** @internal */
 export const jsonReorder = makeReorder(getJsonPriority)
 
-function getJsonPriority(ast: AST.AST): number {
+function getJsonPriority(ast: SchemaAST.AST): number {
   switch (ast._tag) {
     case "BigInt":
     case "Symbol":
@@ -74,18 +74,18 @@ function getJsonPriority(ast: AST.AST): number {
 }
 
 /** @internal */
-export function makeReorder(getPriority: (ast: AST.AST) => number) {
-  return (types: ReadonlyArray<AST.AST>): ReadonlyArray<AST.AST> => {
+export function makeReorder(getPriority: (ast: SchemaAST.AST) => number) {
+  return (types: ReadonlyArray<SchemaAST.AST>): ReadonlyArray<SchemaAST.AST> => {
     // Create a map of original indices for O(1) lookup
-    const indexMap = new Map<AST.AST, number>()
+    const indexMap = new Map<SchemaAST.AST, number>()
     for (let i = 0; i < types.length; i++) {
-      indexMap.set(AST.toEncoded(types[i]), i)
+      indexMap.set(SchemaAST.toEncoded(types[i]), i)
     }
 
     // Create a sorted copy of the types array
     const sortedTypes = [...types].sort((a, b) => {
-      a = AST.toEncoded(a)
-      b = AST.toEncoded(b)
+      a = SchemaAST.toEncoded(a)
+      b = SchemaAST.toEncoded(b)
       const pa = getPriority(a)
       const pb = getPriority(b)
       if (pa !== pb) return pa - pb

package/src/testing/TestSchema.ts

@@ -72,9 +72,9 @@ import * as Effect from "../Effect.ts"
 import * as Record from "../Record.ts"
 import * as Result from "../Result.ts"
 import * as Schema from "../Schema.ts"
-import * as AST from "../SchemaAST.ts"
-import type * as Issue from "../SchemaIssue.ts"
-import * as Parser from "../SchemaParser.ts"
+import * as SchemaAST from "../SchemaAST.ts"
+import type * as SchemaIssue from "../SchemaIssue.ts"
+import * as SchemaParser from "../SchemaParser.ts"
 import * as FastCheck from "../testing/FastCheck.ts"
 
 /**
@@ -132,12 +132,12 @@ export class Asserts<S extends Schema.Top> {
   static ast = {
     fields: {
       equals: (a: Schema.Struct.Fields, b: Schema.Struct.Fields) => {
-        assert.deepStrictEqual(Record.map(a, AST.getAST), Record.map(b, AST.getAST))
+        assert.deepStrictEqual(Record.map(a, SchemaAST.getAST), Record.map(b, SchemaAST.getAST))
       }
     },
     elements: {
       equals: (a: Schema.Tuple.Elements, b: Schema.Tuple.Elements) => {
-        assert.deepStrictEqual(a.map(AST.getAST), b.map(AST.getAST))
+        assert.deepStrictEqual(a.map(SchemaAST.getAST), b.map(SchemaAST.getAST))
       }
     }
   } as const
@@ -173,7 +173,7 @@ export class Asserts<S extends Schema.Top> {
    * @see {@link encoding} for assertions against encoded output
    */
   make(options?: Schema.MakeOptions) {
-    const makeEffect = Parser.makeEffect(this.schema)
+    const makeEffect = SchemaParser.makeEffect(this.schema)
     async function succeed(input: S["Type"]): Promise<void>
     async function succeed(input: S["~type.make.in"], expected: S["Type"]): Promise<void>
     async function succeed(input: S["~type.make.in"], expected?: S["Type"]) {
@@ -226,8 +226,8 @@ export class Asserts<S extends Schema.Top> {
   verifyLosslessTransformation<S extends Schema.Codec<unknown, unknown>>(this: Asserts<S>, options?: {
     readonly params?: FastCheck.Parameters<[S["Type"]]>
   }) {
-    const decodeUnknownEffect = Parser.decodeUnknownEffect(this.schema)
-    const encodeEffect = Parser.encodeEffect(this.schema)
+    const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(this.schema)
+    const encodeEffect = SchemaParser.encodeEffect(this.schema)
     const arbitrary = Schema.toArbitrary(this.schema)
     return FastCheck.assert(
       FastCheck.asyncProperty(arbitrary, async (t) => {
@@ -270,7 +270,7 @@ export class Asserts<S extends Schema.Top> {
    * @see {@link encoding} for assertions in the opposite direction
    */
   decoding(options?: {
-    readonly parseOptions?: AST.ParseOptions | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
   }) {
     return new Decoding(this.schema, options)
   }
@@ -300,7 +300,7 @@ export class Asserts<S extends Schema.Top> {
    * @see {@link decoding} for assertions in the opposite direction
    */
   encoding(options?: {
-    readonly parseOptions?: AST.ParseOptions | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
   }) {
     return new Encoding(this.schema, options)
   }
@@ -374,16 +374,16 @@ export class Decoding<S extends Schema.Top> {
   readonly schema: S
   readonly decodeUnknownEffect: (
     input: unknown,
-    options?: AST.ParseOptions
-  ) => Effect.Effect<S["Type"], Issue.Issue, S["DecodingServices"]>
+    options?: SchemaAST.ParseOptions
+  ) => Effect.Effect<S["Type"], SchemaIssue.Issue, S["DecodingServices"]>
   readonly options?: {
-    readonly parseOptions?: AST.ParseOptions | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
   } | undefined
   constructor(schema: S, options?: {
-    readonly parseOptions?: AST.ParseOptions | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
   }) {
     this.schema = schema
-    this.decodeUnknownEffect = Parser.decodeUnknownEffect(schema)
+    this.decodeUnknownEffect = SchemaParser.decodeUnknownEffect(schema)
     this.options = options
   }
   /**
@@ -514,16 +514,16 @@ export class Encoding<S extends Schema.Top> {
   readonly schema: S
   readonly encodeUnknownEffect: (
     input: unknown,
-    options?: AST.ParseOptions
-  ) => Effect.Effect<S["Type"], Issue.Issue, S["EncodingServices"]>
+    options?: SchemaAST.ParseOptions
+  ) => Effect.Effect<S["Type"], SchemaIssue.Issue, S["EncodingServices"]>
   readonly options?: {
-    readonly parseOptions?: AST.ParseOptions | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
   } | undefined
   constructor(schema: S, options?: {
-    readonly parseOptions?: AST.ParseOptions | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
   }) {
     this.schema = schema
-    this.encodeUnknownEffect = Parser.encodeUnknownEffect(schema)
+    this.encodeUnknownEffect = SchemaParser.encodeUnknownEffect(schema)
     this.options = options
   }
   /**

package/src/unstable/ai/AiError.ts

@@ -1497,7 +1497,8 @@ const TypeId = "~effect/unstable/ai/AiError/AiError" as const
  *
  * **When to use**
  *
- * Use with `Effect.catchReason` for ergonomic error handling.
+ * Use when you need AI errors that can be handled by semantic reason with
+ * `Effect.catchReason`.
  *
  * **Details**
  *
@@ -1647,7 +1648,8 @@ export const make = (params: {
  *
  * **When to use**
  *
- * Use when provider packages can use this as a base for provider-specific mapping.
+ * Use as the base mapping when provider packages translate HTTP status codes into
+ * provider-specific error reasons.
  *
  * **Example** (Mapping an HTTP status to a reason)
  *