effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/internal/schema/toFormatter.ts

@@ -0,0 +1,230 @@
+import type * as Cause from "../../Cause.ts"
+import * as Chunk from "../../Chunk.ts"
+import type * as Exit from "../../Exit.ts"
+import type { Formatter } from "../../Formatter.ts"
+import { format, formatPropertyKey } from "../../Formatter.ts"
+import * as HashMap from "../../HashMap.ts"
+import * as HashSet from "../../HashSet.ts"
+import * as Option from "../../Option.ts"
+import * as Result from "../../Result.ts"
+import type * as Schema from "../../Schema.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
+import * as InternalAnnotations from "./annotations.ts"
+
+function causeReasonToFormatter<E>(error: Formatter<E>, defect: Formatter<unknown>) {
+  return (reason: Cause.Reason<E>) => {
+    switch (reason._tag) {
+      case "Fail":
+        return `Fail(${error(reason.error)})`
+      case "Die":
+        return `Die(${defect(reason.defect)})`
+      case "Interrupt":
+        return "Interrupt"
+    }
+  }
+}
+
+function causeToFormatter<E>(error: Formatter<E>, defect: Formatter<unknown>) {
+  const causeReason = causeReasonToFormatter(error, defect)
+  return (cause: Cause.Cause<E>) => `Cause([${cause.reasons.map(causeReason).join(", ")}])`
+}
+
+/** @internal */
+export function toFormatter<T>(ast: SchemaAST.AST, options?: {
+  readonly onBefore?:
+    | ((ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => Formatter<any>) => Formatter<any> | undefined)
+    | undefined
+}): Formatter<T> {
+  return recur(ast)
+
+  function recur(ast: SchemaAST.AST): Formatter<any> {
+    const annotation = InternalAnnotations.resolve(ast)?.["toFormatter"]
+    if (typeof annotation === "function") {
+      return annotation(SchemaAST.isDeclaration(ast) ? ast.typeParameters.map(recur) : [])
+    }
+    if (options?.onBefore) {
+      const onBefore = options.onBefore(ast, recur)
+      if (onBefore !== undefined) {
+        return onBefore
+      }
+    }
+    return on(ast)
+  }
+
+  function on(ast: SchemaAST.AST): Formatter<any> {
+    switch (ast._tag) {
+      default:
+        return format
+      case "Never":
+        return () => "never"
+      case "Void":
+        return () => "void"
+      case "Declaration": {
+        const representation = (ast.annotations as Schema.Annotations.Declaration<any> | undefined)?.representation
+        if (representation === undefined) return format
+        const typeParameters = ast.typeParameters.map(recur)
+        switch (representation.id) {
+          case "effect/schema/Option": {
+            const [value] = typeParameters
+            return Option.match({
+              onNone: () => "none()",
+              onSome: (value_) => `some(${value(value_)})`
+            })
+          }
+          case "effect/schema/Result": {
+            const [success, failure] = typeParameters
+            return Result.match({
+              onSuccess: (value) => `success(${success(value)})`,
+              onFailure: (error) => `failure(${failure(error)})`
+            })
+          }
+          case "effect/schema/CauseReason":
+            return causeReasonToFormatter(typeParameters[0], typeParameters[1])
+          case "effect/schema/Cause":
+            return causeToFormatter(typeParameters[0], typeParameters[1])
+          case "effect/schema/Exit": {
+            const [value, error, defect] = typeParameters
+            const cause = causeToFormatter(error, defect)
+            return (exit: Exit.Exit<unknown, unknown>) => {
+              switch (exit._tag) {
+                case "Success":
+                  return `Exit.Success(${value(exit.value)})`
+                case "Failure":
+                  return `Exit.Failure(${cause(exit.cause)})`
+              }
+            }
+          }
+          case "effect/schema/ReadonlyMap": {
+            const [key, value] = typeParameters
+            return (map: globalThis.ReadonlyMap<unknown, unknown>) => {
+              const size = map.size
+              if (size === 0) return "ReadonlyMap(0) {}"
+              const entries = globalThis.Array.from(map.entries()).sort().map(([key_, value_]) =>
+                `${key(key_)} => ${value(value_)}`
+              )
+              return `ReadonlyMap(${size}) { ${entries.join(", ")} }`
+            }
+          }
+          case "effect/schema/HashMap": {
+            const [key, value] = typeParameters
+            return (map: HashMap.HashMap<unknown, unknown>) => {
+              const size = HashMap.size(map)
+              if (size === 0) return "HashMap(0) {}"
+              const entries = HashMap.toEntries(map).sort().map(([key_, value_]) => `${key(key_)} => ${value(value_)}`)
+              return `HashMap(${size}) { ${entries.join(", ")} }`
+            }
+          }
+          case "effect/schema/ReadonlySet": {
+            const [value] = typeParameters
+            return (set: globalThis.ReadonlySet<unknown>) => {
+              const size = set.size
+              if (size === 0) return "ReadonlySet(0) {}"
+              const values = globalThis.Array.from(set.values()).sort().map((item) => `${value(item)}`)
+              return `ReadonlySet(${size}) { ${values.join(", ")} }`
+            }
+          }
+          case "effect/schema/HashSet": {
+            const [value] = typeParameters
+            return (set: HashSet.HashSet<unknown>) => {
+              const size = HashSet.size(set)
+              if (size === 0) return "HashSet(0) {}"
+              const values = globalThis.Array.from(set).sort().map((item) => `${value(item)}`)
+              return `HashSet(${size}) { ${values.join(", ")} }`
+            }
+          }
+          case "effect/schema/Chunk": {
+            const [value] = typeParameters
+            return (chunk: Chunk.Chunk<unknown>) => {
+              const size = Chunk.size(chunk)
+              if (size === 0) return "Chunk(0) {}"
+              const values = globalThis.Array.from(chunk).sort().map((item) => `${value(item)}`)
+              return `Chunk(${size}) { ${values.join(", ")} }`
+            }
+          }
+          default:
+            return format
+        }
+      }
+      case "Arrays": {
+        const elements = ast.elements.map((element) => recur(element))
+        const rest = ast.rest.map(recur)
+        return (value) => {
+          const out: Array<string> = []
+          let i = 0
+          for (; i < elements.length; i++) {
+            if (value.length < i + 1) {
+              if (SchemaAST.isOptional(ast.elements[i])) {
+                continue
+              }
+            } else {
+              out.push(elements[i](value[i]))
+            }
+          }
+          if (rest.length > 0) {
+            const [head, ...tail] = rest
+            for (; i < value.length - tail.length; i++) {
+              out.push(head(value[i]))
+            }
+            for (let j = 0; j < tail.length; j++) {
+              out.push(tail[j](value[i + j]))
+            }
+          }
+          return "[" + out.join(", ") + "]"
+        }
+      }
+      case "Objects": {
+        const propertySignatures = ast.propertySignatures.map((signature) => recur(signature.type))
+        const indexSignatures = ast.indexSignatures.map((signature) => recur(signature.type))
+        if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
+          return format
+        }
+        return (value) => {
+          const out: Array<string> = []
+          const visited = new Set<PropertyKey>()
+          for (let i = 0; i < propertySignatures.length; i++) {
+            const signature = ast.propertySignatures[i]
+            const name = signature.name
+            visited.add(name)
+            if (SchemaAST.isOptional(signature.type) && !Object.hasOwn(value, name)) {
+              continue
+            }
+            out.push(`${formatPropertyKey(name)}: ${propertySignatures[i](value[name])}`)
+          }
+          for (let i = 0; i < indexSignatures.length; i++) {
+            const keys = SchemaAST.getIndexSignatureKeys(value, ast.indexSignatures[i].parameter)
+            for (const key of keys) {
+              if (visited.has(key)) {
+                continue
+              }
+              visited.add(key)
+              out.push(`${formatPropertyKey(key)}: ${indexSignatures[i](value[key])}`)
+            }
+          }
+          return out.length > 0 ? "{ " + out.join(", ") + " }" : "{}"
+        }
+      }
+      case "Union": {
+        const types = SchemaAST.toType(ast).types
+        const getCandidates = (value: any) => SchemaAST.getCandidates(value, types)
+        const compiled = new Map(
+          types.map((candidate, i) => [candidate, [SchemaParser._is(candidate), recur(ast.types[i])] as const] as const)
+        )
+        return (value) => {
+          const candidates = getCandidates(value)
+          for (let i = 0; i < candidates.length; i++) {
+            const [is, formatter] = compiled.get(candidates[i])!
+            if (is(value)) {
+              return formatter(value)
+            }
+          }
+          return format(value)
+        }
+      }
+      case "Suspend": {
+        const get = SchemaAST.memoizeThunk(() => recur(ast.thunk()))
+        return (value) => get()(value)
+      }
+    }
+  }
+}

package/src/internal/schema/toIso.ts

@@ -0,0 +1,20 @@
+import * as Optic from "../../Optic.ts"
+import type * as Schema from "../../Schema.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
+import * as InternalToCodec from "./toCodec.ts"
+
+/** @internal */
+export function toIso<S extends Schema.Constraint>(schema: S): Optic.Iso<S["Type"], S["Iso"]> {
+  const serializer = InternalToCodec.toCodecIso(schema)
+  return Optic.makeIso(SchemaParser.encodeSync(serializer), SchemaParser.decodeSync(serializer))
+}
+
+/** @internal */
+export function toIsoSource<S extends Schema.Constraint>(_: S): Optic.Iso<S["Type"], S["Type"]> {
+  return Optic.id()
+}
+
+/** @internal */
+export function toIsoFocus<S extends Schema.Constraint>(_: S): Optic.Iso<S["Iso"], S["Iso"]> {
+  return Optic.id()
+}

package/src/internal/schema/toJsonSchemaDocument.ts

@@ -1,11 +1,11 @@
 import * as Arr from "../../Array.ts"
 import * as Equal from "../../Equal.ts"
-import { escapeToken, unescapeToken } from "../../JsonPointer.ts"
+import { decodeUriFragment, formatUriFragmentToken, unescapeToken } from "../../JsonPointer.ts"
 import type * as JsonSchema from "../../JsonSchema.ts"
 import { rewriteRefs } from "../../JsonSchema.ts"
 import * as RegEx from "../../RegExp.ts"
 import type * as Schema from "../../Schema.ts"
-import * as SchemaAST from "../../SchemaAST.ts"
+import * as InternalAST from "../../SchemaAST.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import { errorWithPath } from "../errors.ts"
 import * as InternalRecord from "../record.ts"
@@ -16,6 +16,10 @@ type CheckRepresentationAnnotation = SchemaRepresentation.CheckRepresentationAnn
   SchemaRepresentation.Representation
 >
 
+function formatDefinitionReference(key: string): string {
+  return `#/$defs/${formatUriFragmentToken(key)}`
+}
+
 const jsonSchemaAnnotationExcludedKeys = new Set([
   ...InternalAnnotations.annotationExcludedKeys,
   InternalAnnotations.IDENTIFIER_FALLBACK_KEY,
@@ -37,9 +41,9 @@ function collectJsonSchemaAnnotations(
   else if (options?.generateDescriptions === true && typeof expected === "string") out.description = expected
 
   const defaultValue = annotations.default
-  if (SchemaAST.isJson(defaultValue)) out.default = defaultValue
+  if (InternalAST.isJson(defaultValue)) out.default = defaultValue
   const examples = annotations.examples
-  if (Array.isArray(examples) && SchemaAST.isJson(examples)) out.examples = examples
+  if (Array.isArray(examples) && InternalAST.isJson(examples)) out.examples = examples
   const readOnly = annotations.readOnly
   if (typeof readOnly === "boolean") out.readOnly = readOnly
   const writeOnly = annotations.writeOnly
@@ -51,7 +55,7 @@ function collectJsonSchemaAnnotations(
   const contentMediaType = annotations.contentMediaType
   if (typeof contentMediaType === "string") out.contentMediaType = contentMediaType
   const contentSchema = annotations.contentSchema
-  if (SchemaAST.isJson(contentSchema)) out.contentSchema = contentSchema
+  if (InternalAST.isJson(contentSchema)) out.contentSchema = contentSchema
 
   if (options?.includeAnnotationKey !== undefined) {
     for (const [key, value] of Object.entries(annotations)) {
@@ -61,7 +65,7 @@ function collectJsonSchemaAnnotations(
       ) {
         continue
       }
-      if (SchemaAST.isJson(value)) InternalRecord.assignProperty(out, key, value)
+      if (InternalAST.isJson(value)) InternalRecord.assignProperty(out, key, value)
     }
   }
 
@@ -102,8 +106,10 @@ function extractJsonSchemaNumberType(schema: JsonSchema.JsonSchema): {
 }
 
 function isJsonSchemaNumberEncoding(schema: JsonSchema.JsonSchema): boolean {
-  return Array.isArray(schema.anyOf) && schema.anyOf.length === 4 && schema.anyOf[0]?.type === "number" &&
-    schema.anyOf.slice(1).every((member) => member.type === "string")
+  if (!Array.isArray(schema.anyOf) || schema.anyOf.length !== 2 || schema.anyOf[0]?.type !== "number") return false
+  const special = schema.anyOf[1]
+  return special?.type === "string" && Array.isArray(special.enum) && special.enum.length === 3 &&
+    special.enum.includes("NaN") && special.enum.includes("Infinity") && special.enum.includes("-Infinity")
 }
 
 // Keep this allowlist closed: applicators and dependent keywords can change meaning when moved across schema objects.
@@ -172,7 +178,6 @@ function compileJsonSchema(
   const definitionStates = new Map<string, JsonSchema.JsonSchema | string | null>()
   const compiledRepresentations = new WeakMap<SchemaRepresentation.Representation, JsonSchema.JsonSchema>()
   const fallbackDefinitions = new Map<string, Array<string>>()
-  let hasAliases = false
   const referenceKeys = Object.keys(references)
   for (const key of referenceKeys) {
     compileDefinition(key, ["references", key])
@@ -209,7 +214,6 @@ function compileJsonSchema(
         if (candidates === undefined) fallbackDefinitions.set(fallback, [key])
         else candidates.push(key)
       } else {
-        hasAliases = true
         definitionStates.set(key, match)
         return match
       }
@@ -219,12 +223,24 @@ function compileJsonSchema(
   }
 
   function finalizeJsonSchema(schema: JsonSchema.JsonSchema): JsonSchema.JsonSchema {
-    if (!hasAliases) return schema
-    return rewriteRefs(schema, ($ref) =>
-      $ref.replace(/^#\/\$defs\/([^/]*)/, (match, token) => {
-        const canonical = definitionStates.get(unescapeToken(token))
-        return typeof canonical === "string" ? `#/$defs/${escapeToken(canonical)}` : match
-      }))
+    return rewriteRefs(schema, ($ref) => {
+      const pointer = decodeUriFragment($ref)
+      if (pointer === undefined) {
+        if (/^#(?:\/|%2f)/i.test($ref)) {
+          throw new Error(`Invalid JSON Pointer URI fragment ${JSON.stringify($ref)}`)
+        }
+        return $ref
+      }
+      if (!pointer.startsWith("/$defs/")) return $ref
+      const separator = pointer.indexOf("/", 7)
+      const canonical = definitionStates.get(unescapeToken(pointer.slice(7, separator < 0 ? undefined : separator)))
+      if (typeof canonical !== "string") return $ref
+      // URI-encoded slashes separate pointer tokens; only ~1 represents a slash within a token.
+      return $ref.replace(
+        /^#(?:\/|%2f).*?(?:\/|%2f).*?(?=\/|%2f|$)/i,
+        formatDefinitionReference(canonical)
+      )
+    })
   }
 
   function getIdentifierFallback(
@@ -283,7 +299,7 @@ function compileJsonSchema(
   ): JsonSchema.JsonSchema {
     if (representation._tag === "Reference") {
       const canonical = compileDefinition(representation.$ref, path)
-      return { $ref: `#/$defs/${escapeToken(canonical)}` }
+      return { $ref: formatDefinitionReference(canonical) }
     }
     const cached = compiledRepresentations.get(representation)
     if (cached !== undefined) return cached
@@ -321,8 +337,11 @@ function compileJsonSchema(
       case "BigInt":
         return { type: "string", allOf: [{ pattern: "^-?\\d+$" }] }
       case "Symbol":
+        return { type: "string", allOf: [{ pattern: "^Symbol\\(([\\s\\S]*)\\)$" }] }
       case "UniqueSymbol":
-        return { type: "string", allOf: [{ pattern: "^Symbol\\((.*)\\)$" }] }
+        return globalThis.Symbol.keyFor(representation.symbol) === undefined
+          ? { not: {} }
+          : { type: "string", enum: [globalThis.String(representation.symbol)] }
       case "Declaration": {
         return {}
       }
@@ -336,9 +355,7 @@ function compileJsonSchema(
         return {
           anyOf: [
             { type: "number" },
-            { type: "string", enum: ["NaN"] },
-            { type: "string", enum: ["Infinity"] },
-            { type: "string", enum: ["-Infinity"] }
+            { type: "string", enum: ["NaN", "Infinity", "-Infinity"] }
           ]
         }
       case "Boolean":
@@ -350,11 +367,15 @@ function compileJsonSchema(
           : { type: typeof literal, enum: [literal] }
       }
       case "Enum": {
-        const types = representation.enums.map(([title, literal]) =>
-          typeof literal === "number" && !globalThis.Number.isFinite(literal)
-            ? { type: "string", enum: [globalThis.String(literal)], title }
-            : { type: typeof literal, enum: [literal], title }
-        )
+        const types = representation.enums.map(([title, literal], index) => {
+          if (typeof literal === "number" && !globalThis.Number.isFinite(literal)) {
+            throw errorWithPath(
+              `Invalid numeric enum value ${globalThis.String(literal)}`,
+              [...path, "enums", index, 1]
+            )
+          }
+          return { type: typeof literal, enum: [literal], title }
+        })
         return types.length === 0 ? { not: {} } : { anyOf: types }
       }
       case "TemplateLiteral":
@@ -388,7 +409,7 @@ function compileJsonSchema(
       }
       case "Objects": {
         if (representation.propertySignatures.length === 0 && representation.indexSignatures.length === 0) {
-          return { anyOf: [{ type: "object" }, { type: "array" }] }
+          return { not: { type: "null" } }
         }
         const out: JsonSchema.JsonSchema = { type: "object" }
         const properties: Record<string, JsonSchema.JsonSchema> = {}
@@ -416,21 +437,28 @@ function compileJsonSchema(
         if (representation.propertySignatures.length > 0) out.properties = properties
         if (required.length > 0) out.required = required
         const patternProperties: Record<string, JsonSchema.JsonSchema | false> = {}
-        const additionalProperties: Array<JsonSchema.JsonSchema | false> = []
+        const additionalPropertySchemas: Array<JsonSchema.JsonSchema | false> = []
+        const indexValueSchemas: Array<JsonSchema.JsonSchema | false> = []
+        let hasUnrepresentableIndexPattern = false
         for (let index = 0; index < representation.indexSignatures.length; index++) {
           const signature = representation.indexSignatures[index]
           let type: JsonSchema.JsonSchema | false = recur(
             signature.type,
             [...path, "indexSignatures", index, "type"]
           )
-          if (Object.keys(type).length === 1 && "not" in type) type = false
+          if (Equal.equals(type, { not: {} })) type = false
+          indexValueSchemas.push(type)
           const patterns = getParameterPatterns(
             signature.parameter,
             [...path, "indexSignatures", index, "parameter"],
             new Set()
           )
+          if (patterns === undefined) {
+            hasUnrepresentableIndexPattern = true
+            continue
+          }
           if (patterns.length === 0) {
-            additionalProperties.push(type)
+            additionalPropertySchemas.push(type)
           } else {
             for (const pattern of patterns) {
               const previous = patternProperties[pattern]
@@ -450,16 +478,36 @@ function compileJsonSchema(
         if (hasPatternProperties) {
           out.patternProperties = patternProperties
         }
-        if (representation.indexSignatures.length === 0) {
-          out.additionalProperties = options?.additionalProperties ?? false
+        if (hasUnrepresentableIndexPattern && options?.onExcessProperty === "error") {
+          const propertyNames: Array<JsonSchema.JsonSchema> = []
+          if (representation.propertySignatures.length > 0) {
+            propertyNames.push({ enum: Object.keys(properties) })
+          }
+          for (let index = 0; index < representation.indexSignatures.length; index++) {
+            propertyNames.push(
+              recur(
+                representation.indexSignatures[index].parameter,
+                [...path, "indexSignatures", index, "parameter"]
+              )
+            )
+          }
+          out.propertyNames = propertyNames.length === 1 ? propertyNames[0] : { anyOf: propertyNames }
+          out.additionalProperties = indexValueSchemas.length === 1
+            ? indexValueSchemas[0]
+            : { anyOf: indexValueSchemas }
+          if (additionalPropertySchemas.length > 0) {
+            out.allOf = additionalPropertySchemas.map((type) => ({ type: "object", additionalProperties: type }))
+          }
+        } else if (additionalPropertySchemas.length === 0) {
+          out.additionalProperties = hasUnrepresentableIndexPattern || options?.onExcessProperty !== "error"
         } else if (
-          additionalProperties.length === 1 &&
+          additionalPropertySchemas.length === 1 &&
           representation.propertySignatures.length === 0 &&
           !hasPatternProperties
         ) {
-          out.additionalProperties = additionalProperties[0]
-        } else if (additionalProperties.length > 0) {
-          out.allOf = additionalProperties.map((type) => ({ type: "object", additionalProperties: type }))
+          out.additionalProperties = additionalPropertySchemas[0]
+        } else if (additionalPropertySchemas.length > 0) {
+          out.allOf = additionalPropertySchemas.map((type) => ({ type: "object", additionalProperties: type }))
         }
         if (
           typeof out.additionalProperties === "object" &&
@@ -473,11 +521,12 @@ function compileJsonSchema(
       case "Union": {
         const types = representation.types.map((type, index) => recur(type, [...path, "types", index]))
         if (types.length === 0) return { not: {} }
-        if (types.length > 1) {
+        const mode = representation.options?.mode ?? "anyOf"
+        if (mode === "anyOf" && types.length > 1) {
           const compacted = compactEnums(types)
           if (compacted !== undefined) return compacted
         }
-        return representation.mode === "anyOf" ? { anyOf: types } : { oneOf: types }
+        return mode === "anyOf" ? { anyOf: types } : { oneOf: types }
       }
     }
   }
@@ -486,25 +535,47 @@ function compileJsonSchema(
     parameter: SchemaRepresentation.Representation,
     path: Path,
     seenReferences: ReadonlySet<string>
-  ): ReadonlyArray<string> {
+  ): ReadonlyArray<string> | undefined {
     switch (parameter._tag) {
       case "Reference": {
         if (!Object.hasOwn(references, parameter.$ref)) {
           throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path, "$ref"])
         }
         compileDefinition(parameter.$ref, path)
-        if (seenReferences.has(parameter.$ref)) return []
+        if (seenReferences.has(parameter.$ref)) return undefined
         const next = new Set(seenReferences).add(parameter.$ref)
         return getParameterPatterns(references[parameter.$ref], ["references", parameter.$ref], next)
       }
-      case "String":
-        return collectPatterns(recur(parameter, path))
+      case "String": {
+        if (parameter.checks.length === 0) return []
+        if (
+          parameter.checks.length !== 1 ||
+          parameter.checks[0]._tag !== "Filter" ||
+          parameter.checks[0].annotations?.toJsonSchema === undefined
+        ) {
+          return undefined
+        }
+        const schema = recur(parameter, path)
+        return schema.type === "string" && typeof schema.pattern === "string" &&
+            hasOnlyKeywords(schema, "|type|pattern|title|description|default|examples|readOnly|writeOnly|")
+          ? [schema.pattern]
+          : undefined
+      }
       case "TemplateLiteral":
-        return [`^${parameter.parts.map(getPartPattern).join("")}$`]
-      case "Union":
-        return parameter.types.flatMap((type, index) =>
-          getParameterPatterns(type, [...path, "types", index], seenReferences)
-        )
+        return parameter.checks.length === 0 ? [`^${parameter.parts.map(getPartPattern).join("")}$`] : undefined
+      case "Union": {
+        if (parameter.types.length === 0 || parameter.checks.length > 0 || parameter.options?.mode === "oneOf") {
+          return undefined
+        }
+        const patterns: Array<string> = []
+        for (let index = 0; index < parameter.types.length; index++) {
+          const memberPatterns = getParameterPatterns(parameter.types[index], [...path, "types", index], seenReferences)
+          if (memberPatterns === undefined) return undefined
+          if (memberPatterns.length === 0) return []
+          patterns.push(...memberPatterns)
+        }
+        return patterns
+      }
       default:
         throw errorWithPath("Invalid schema representation document", path)
     }
@@ -528,25 +599,12 @@ function compactEnums(
     }
     if (sharedType === undefined) sharedType = schema.type
     else if (schema.type !== sharedType) return undefined
-    values.push(...schema.enum)
-  }
-  return { type: sharedType, enum: values }
-}
-
-function collectPatterns(schema: JsonSchema.JsonSchema): ReadonlyArray<string> {
-  const patterns: Array<string> = []
-  if (typeof schema.pattern === "string") patterns.push(schema.pattern)
-  for (const key of ["allOf", "anyOf", "oneOf"] as const) {
-    const members = schema[key]
-    if (Array.isArray(members)) {
-      for (const member of members) {
-        if (typeof member === "object" && member !== null && !Array.isArray(member)) {
-          patterns.push(...collectPatterns(member))
-        }
-      }
+    for (const value of schema.enum) {
+      if (values.includes(value)) return undefined
+      values.push(value)
     }
   }
-  return patterns
+  return { type: sharedType, enum: values }
 }
 
 function getPartPattern(part: SchemaRepresentation.Representation): string {
@@ -554,13 +612,13 @@ function getPartPattern(part: SchemaRepresentation.Representation): string {
     case "Literal":
       return RegEx.escape(globalThis.String(part.literal))
     case "String":
-      return SchemaAST.STRING_PATTERN
+      return InternalAST.STRING_PATTERN
     case "Number":
-      return SchemaAST.FINITE_PATTERN
+      return InternalAST.FINITE_PATTERN
     case "TemplateLiteral":
       return part.parts.map(getPartPattern).join("")
     case "Union":
-      return part.types.map(getPartPattern).join("|")
+      return `(?:${part.types.map(getPartPattern).join("|")})`
     default:
       throw errorWithPath("Invalid schema representation document", [])
   }

package/src/internal/schema/toRepresentation.ts

@@ -283,7 +283,7 @@ export function toRepresentations(
         return {
           _tag: "Union",
           types: ast.types.map((ast) => recur(ast)),
-          mode: ast.mode,
+          ...(ast.options === undefined ? {} : { options: ast.options }),
           checks,
           ...annotationsField(ast.annotations)
         }

package/src/internal/schemaError.ts

@@ -0,0 +1,8 @@
+import * as Predicate from "../Predicate.ts"
+import type { SchemaError } from "../Schema.ts"
+
+export const SchemaErrorTypeId = "~effect/Schema/SchemaError"
+
+export function isSchemaError(u: unknown): u is SchemaError {
+  return Predicate.hasProperty(u, SchemaErrorTypeId) && u[SchemaErrorTypeId] === SchemaErrorTypeId
+}

package/src/internal/stream.ts

@@ -12,17 +12,25 @@ const streamVariance = {
   _A: identity
 }
 
-const StreamProto = {
+const Stream: {
+  new<A extends Arr.NonEmptyReadonlyArray<any>, E, R>(
+    channel: Channel.Channel<A, E, void, unknown, unknown, unknown, R>
+  ): Stream<A extends Arr.NonEmptyReadonlyArray<infer A> ? A : never, E, R>
+} = function<A extends Arr.NonEmptyReadonlyArray<any>, E, R>(
+  this: any,
+  channel: Channel.Channel<A, E, void, unknown, unknown, unknown, R>
+) {
+  this.channel = channel
+} as any
+
+Stream.prototype = {
   [TypeId]: streamVariance,
   pipe() {
     return pipeArguments(this, arguments)
   }
 }
+
 /** @internal */
 export const fromChannel = <A extends Arr.NonEmptyReadonlyArray<any>, E, R>(
   channel: Channel.Channel<A, E, void, unknown, unknown, unknown, R>
-): Stream<A extends Arr.NonEmptyReadonlyArray<infer A> ? A : never, E, R> => {
-  const self = Object.create(StreamProto)
-  self.channel = channel
-  return self
-}
+): Stream<A extends Arr.NonEmptyReadonlyArray<infer A> ? A : never, E, R> => new Stream(channel)