effect 4.0.0-beta.73 → 4.0.0-beta.75

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/TestClock.ts

@@ -167,7 +167,7 @@ export declare namespace TestClock {
    * })
    * ```
    *
-   * @category models
+   * @category options
    * @since 4.0.0
    */
   export interface Options {
@@ -419,7 +419,7 @@ export const layer: (options?: TestClock.Options) => Layer.Layer<TestClock> = fl
  * })
  * ```
  *
- * @category utils
+ * @category testing
  * @since 2.0.0
  */
 export const testClockWith = <A, E, R>(
@@ -454,7 +454,7 @@ export const testClockWith = <A, E, R>(
  * })
  * ```
  *
- * @category utils
+ * @category testing
  * @since 2.0.0
  */
 export const adjust = (duration: Duration.Input): Effect.Effect<void> =>
@@ -488,7 +488,7 @@ export const adjust = (duration: Duration.Input): Effect.Effect<void> =>
  * })
  * ```
  *
- * @category utils
+ * @category testing
  * @since 2.0.0
  */
 export const setTime = (timestamp: number): Effect.Effect<void> =>
@@ -522,7 +522,7 @@ export const setTime = (timestamp: number): Effect.Effect<void> =>
  * })
  * ```
  *
- * @category utils
+ * @category testing
  * @since 4.0.0
  */
 export const withLive = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>

package/src/testing/TestConsole.ts

@@ -276,7 +276,7 @@ export const make = Effect.gen(function*() {
  * @see {@link logLines} for reading captured `Console.log` calls directly
  * @see {@link errorLines} for reading captured `Console.error` calls directly
  *
- * @category utils
+ * @category testing
  * @since 4.0.0
  */
 export const testConsoleWith = <A, E, R>(f: (console: TestConsole) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
@@ -351,7 +351,7 @@ export const layer: Layer.Layer<TestConsole> = Layer.effect(Console.Console)(mak
  * @see {@link errorLines} for reading captured `Console.error` output
  * @see {@link layer} for capturing console calls during a test
  *
- * @category utils
+ * @category testing
  * @since 4.0.0
  */
 export const logLines: Effect.Effect<ReadonlyArray<unknown>, never, never> = testConsoleWith(
@@ -390,7 +390,7 @@ export const logLines: Effect.Effect<ReadonlyArray<unknown>, never, never> = tes
  * @see {@link logLines} for reading captured `Console.log` output
  * @see {@link layer} for capturing console calls during a test
  *
- * @category utils
+ * @category testing
  * @since 4.0.0
  */
 export const errorLines: Effect.Effect<ReadonlyArray<unknown>, never, never> = testConsoleWith(

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)
  *