effect 4.0.0-beta.97 → 4.0.0-beta.98

package/src/Schema.ts

@@ -40,7 +40,6 @@ import * as InternalArbitrary from "./internal/schema/arbitrary.ts"
 import * as InternalEquivalence from "./internal/schema/equivalence.ts"
 import * as InternalStandard from "./internal/schema/representation.ts"
 import * as InternalSchema from "./internal/schema/schema.ts"
-import { SchemaError } from "./internal/schema/schema.ts"
 import * as JsonPatch from "./JsonPatch.ts"
 import * as JsonSchema from "./JsonSchema.ts"
 import { remainder } from "./Number.ts"
@@ -54,6 +53,7 @@ import * as Redacted_ from "./Redacted.ts"
 import * as Result_ from "./Result.ts"
 import * as Scheduler from "./Scheduler.ts"
 import * as SchemaAST from "./SchemaAST.ts"
+import { isSchemaError, SchemaError } from "./SchemaError.ts"
 import * as SchemaGetter from "./SchemaGetter.ts"
 import * as SchemaIssue from "./SchemaIssue.ts"
 import * as SchemaParser from "./SchemaParser.ts"
@@ -1029,6 +1029,27 @@ export interface Optic<out T, out Iso> extends Schema<T> {
 }
 
 export {
+  /**
+   * Returns `true` if `u` is a {@link SchemaError}.
+   *
+   * **Example** (Narrowing Schema errors in a catch block)
+   *
+   * ```ts
+   * import { Schema } from "effect"
+   *
+   * try {
+   *   Schema.decodeUnknownSync(Schema.Number)("oops")
+   * } catch (err) {
+   *   if (Schema.isSchemaError(err)) {
+   *     console.log(err._tag) // "SchemaError"
+   *   }
+   * }
+   * ```
+   *
+   * @category guards
+   * @since 4.0.0
+   */
+  isSchemaError,
   /**
    * Error thrown (or returned as the error channel value) when schema decoding
    * or encoding fails.
@@ -1063,30 +1084,6 @@ export {
   SchemaError
 }
 
-/**
- * Returns `true` if `u` is a {@link SchemaError}.
- *
- * **Example** (Narrowing Schema errors in a catch block)
- *
- * ```ts
- * import { Schema } from "effect"
- *
- * try {
- *   Schema.decodeUnknownSync(Schema.Number)("oops")
- * } catch (err) {
- *   if (Schema.isSchemaError(err)) {
- *     console.log(err._tag) // "SchemaError"
- *   }
- * }
- * ```
- *
- * @category guards
- * @since 4.0.0
- */
-export function isSchemaError(u: unknown): u is SchemaError {
-  return Predicate.hasProperty(u, InternalSchema.SchemaErrorTypeId)
-}
-
 function makeStandardResult<A>(exit: Exit_.Exit<StandardSchemaV1.Result<A>>): StandardSchemaV1.Result<A> {
   return Exit_.isSuccess(exit) ? exit.value : {
     issues: [{ message: Cause_.pretty(exit.cause) }]
@@ -1374,7 +1371,7 @@ export function decodeUnknownEffect<S extends Constraint>(schema: S, options?: S
     input: unknown,
     options?: SchemaAST.ParseOptions
   ): Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]> => {
-    return InternalSchema.mapSchemaIssueEffect(parser(input, options))
+    return InternalSchema.fromIssueEffect(parser(input, options))
   }
 }
 
@@ -1478,10 +1475,16 @@ function runSchemaErrorSync<A>(
 export function decodeUnknownExit<S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
   const parser = SchemaParser.decodeUnknownExit(schema, options)
   return (input: unknown, options?: SchemaAST.ParseOptions): Exit_.Exit<S["Type"], SchemaError> => {
-    return InternalSchema.mapSchemaIssueExit(parser(input, options))
+    return fromIssueExit(parser(input, options))
   }
 }
 
+function fromIssueExit<A>(exit: Exit_.Exit<A, SchemaIssue.Issue>): Exit_.Exit<A, SchemaError> {
+  return Exit_.isSuccess(exit)
+    ? Exit_.succeed(exit.value)
+    : Exit_.failCause(Cause_.map(exit.cause, (issue) => new SchemaError(issue)))
+}
+
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema
  * synchronously, returning an `Exit` that is either a `Success` with the decoded
@@ -1837,7 +1840,7 @@ export function encodeUnknownEffect<S extends Constraint>(schema: S, options?: S
     input: unknown,
     options?: SchemaAST.ParseOptions
   ): Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]> => {
-    return InternalSchema.mapSchemaIssueEffect(parser(input, options))
+    return InternalSchema.fromIssueEffect(parser(input, options))
   }
 }
 
@@ -1902,7 +1905,7 @@ export const encodeEffect: <S extends Constraint>(
 export function encodeUnknownExit<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
   const parser = SchemaParser.encodeUnknownExit(schema, options)
   return (input: unknown, options?: SchemaAST.ParseOptions): Exit_.Exit<S["Encoded"], SchemaError> => {
-    return InternalSchema.mapSchemaIssueExit(parser(input, options))
+    return fromIssueExit(parser(input, options))
   }
 }
 
@@ -5695,7 +5698,13 @@ export function withConstructorDefault<S extends Constraint & WithoutConstructor
   defaultValue: Effect.Effect<S["~type.make.in"], SchemaError>
 ) {
   return (schema: S): withConstructorDefault<S> =>
-    make(SchemaAST.withConstructorDefault(schema.ast, InternalSchema.mapSchemaErrorEffect(defaultValue)), { schema })
+    make(SchemaAST.withConstructorDefault(schema.ast, toIssueEffect(defaultValue)), { schema })
+}
+
+function toIssueEffect<A, R>(
+  self: Effect.Effect<A, SchemaError, R>
+): Effect.Effect<A, SchemaIssue.Issue, R> {
+  return Effect.catchCause(self, (cause) => Effect.failCauseSync(() => Cause_.map(cause, (error) => error.issue)))
 }
 
 /**
@@ -5767,7 +5776,7 @@ export function withDecodingDefaultKey<S extends Constraint, R = never>(
   const encode = options?.encodingStrategy === "omit" ? SchemaGetter.omit() : SchemaGetter.passthrough()
   return (self: S): withDecodingDefaultKey<S, R> => {
     return optionalKey(toEncoded(self)).pipe(decodeTo(self, {
-      decode: SchemaGetter.withDefault(InternalSchema.mapSchemaErrorEffect(defaultValue)),
+      decode: SchemaGetter.withDefault(toIssueEffect(defaultValue)),
       encode
     }))
   }
@@ -5875,7 +5884,7 @@ export function withDecodingDefault<S extends Constraint, R = never>(
   const encode = options?.encodingStrategy === "omit" ? SchemaGetter.omit() : SchemaGetter.passthrough()
   return (self: S): withDecodingDefault<S, R> => {
     return optional(toEncoded(self)).pipe(decodeTo(self, {
-      decode: SchemaGetter.withDefault(InternalSchema.mapSchemaErrorEffect(defaultValue)),
+      decode: SchemaGetter.withDefault(toIssueEffect(defaultValue)),
       encode
     }))
   }
@@ -13599,8 +13608,7 @@ export function toFormatter<S extends Constraint>(schema: S, options?: {
             // handle post rest elements
             // ---------------------------------------------
             for (let j = 0; j < tail.length; j++) {
-              i += j
-              out.push(tail[j](t[i]))
+              out.push(tail[j](t[i + j]))
             }
           }
 

package/src/SchemaAST.ts

@@ -2504,9 +2504,9 @@ export function collectSentinels(ast: AST): Array<Sentinel> {
 }
 
 type CandidateIndex = {
-  byType?: { [K in Type]?: Array<AST> }
-  bySentinel?: Map<PropertyKey, Map<LiteralValue | symbol, Array<AST>>>
-  otherwise?: { [K in Type]?: Array<AST> }
+  byType?: { [K in Type]?: Array<number> }
+  bySentinel?: Map<PropertyKey, Map<LiteralValue | symbol, Array<number>>>
+  otherwise?: { [K in Type]?: Array<number> }
 }
 
 const candidateIndexCache = new WeakMap<ReadonlyArray<AST>, CandidateIndex>()
@@ -2516,16 +2516,17 @@ function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
   if (idx) return idx
 
   idx = {}
-  for (const a of types) {
+  for (let i = 0; i < types.length; i++) {
+    const a = types[i]
     const encoded = toEncoded(a)
     if (isNever(encoded)) continue
 
-    const types = getCandidateTypes(encoded)
+    const candidateTypes = getCandidateTypes(encoded)
     const sentinels = collectSentinels(encoded)
 
     // by-type (always filled – cheap primary filter)
     idx.byType ??= {}
-    for (const t of types) (idx.byType[t] ??= []).push(a)
+    for (const t of candidateTypes) (idx.byType[t] ??= []).push(i)
 
     if (sentinels.length > 0) { // discriminated variants
       idx.bySentinel ??= new Map()
@@ -2534,11 +2535,11 @@ function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
         if (!m) idx.bySentinel.set(key, m = new Map())
         let arr = m.get(literal)
         if (!arr) m.set(literal, arr = [])
-        arr.push(a)
+        arr.push(i)
       }
     } else { // non-discriminated
       idx.otherwise ??= {}
-      for (const t of types) (idx.otherwise[t] ??= []).push(a)
+      for (const t of candidateTypes) (idx.otherwise[t] ??= []).push(i)
     }
   }
 
@@ -2571,18 +2572,22 @@ export function getCandidates(input: any, types: ReadonlyArray<AST>): ReadonlyAr
   if (idx.bySentinel) {
     const base = idx.otherwise?.[runtimeType] ?? []
     if (runtimeType === "object" || runtimeType === "array") {
+      const selected = new Set(base)
       for (const [k, m] of idx.bySentinel) {
         if (Object.hasOwn(input, k)) {
           const match = m.get((input as any)[k])
-          if (match) return [...match, ...base].filter(filterLiterals(input))
+          if (match) {
+            for (const candidate of match) selected.add(candidate)
+          }
         }
       }
+      return Array.from(selected).sort((a, b) => a - b).map((i) => types[i]).filter(filterLiterals(input))
     }
-    return base
+    return base.map((i) => types[i])
   }
 
   // 2. Fallback: runtime-type dispatch only
-  return (idx.byType?.[runtimeType] ?? []).filter(filterLiterals(input))
+  return (idx.byType?.[runtimeType] ?? []).map((i) => types[i]).filter(filterLiterals(input))
 }
 
 /**
@@ -2659,7 +2664,7 @@ export class Union<A extends AST = AST> extends Base {
         options
       }
       const concurrency = resolveConcurrency(options?.concurrency)
-      const eff = parseUnion(state, candidates, concurrency)
+      const eff = parseUnion(state, candidates, concurrency ? { ...concurrency, orderedStep: true } : undefined)
       if (!eff) {
         return state.out
           ? Effect.succeed(state.out)
@@ -3883,8 +3888,15 @@ export function isJson(u: unknown): u is Schema.Json {
     if (validated.has(u)) {
       return true
     }
+    const isArray = Array.isArray(u)
+    if (!isArray) {
+      const prototype = Object.getPrototypeOf(u)
+      if (prototype !== null && Object.getPrototypeOf(prototype) !== null) {
+        return false
+      }
+    }
     onPath.add(u)
-    const ok = Array.isArray(u)
+    const ok = isArray
       ? u.every(recur)
       : Object.keys(u).every((key) => recur((u as Record<string, unknown>)[key]))
     // Pop on exit so siblings reaching the same node via a different path

package/src/SchemaError.ts

@@ -0,0 +1,64 @@
+/**
+ * @since 4.0.0
+ */
+import * as Data from "./Data.ts"
+import * as Predicate from "./Predicate.ts"
+import type { Issue } from "./SchemaIssue.ts"
+
+const TypeId = "~effect/SchemaError/SchemaError"
+
+/**
+ * Error thrown (or returned as the error channel value) when schema decoding
+ * or encoding fails.
+ *
+ * **Details**
+ *
+ * The `issue` field contains a structured {@link Issue} tree describing
+ * every validation failure, including the path to the problematic value,
+ * expected types, and actual values received. `message` renders the issue tree
+ * as a human-readable string.
+ *
+ * Use {@link isSchemaError} to narrow an unknown value to `SchemaError`.
+ *
+ * **Example** (Catching a SchemaError)
+ *
+ * ```ts
+ * import { Schema } from "effect"
+ *
+ * try {
+ *   Schema.decodeUnknownSync(Schema.Number)("not a number")
+ * } catch (err) {
+ *   if (Schema.isSchemaError(err)) {
+ *     console.log(err.message)
+ *     // Expected number, actual "not a number"
+ *   }
+ * }
+ * ```
+ *
+ * @category errors
+ * @since 4.0.0
+ */
+export class SchemaError extends Data.TaggedError("SchemaError")<{
+  readonly issue: Issue
+}> {
+  readonly [TypeId]: typeof TypeId = TypeId
+  constructor(issue: Issue) {
+    super({ issue })
+  }
+  override get message() {
+    return this.issue.toString()
+  }
+  override toString() {
+    return `SchemaError(${this.message})`
+  }
+}
+
+/**
+ * Returns `true` if `u` is a {@link SchemaError}.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export function isSchemaError(u: unknown): u is SchemaError {
+  return Predicate.hasProperty(u, TypeId)
+}

package/src/SchemaGetter.ts

@@ -14,6 +14,7 @@
 import * as DateTime from "./DateTime.ts"
 import * as Effect from "./Effect.ts"
 import * as Encoding from "./Encoding.ts"
+import * as internalRecord from "./internal/record.ts"
 import * as Option from "./Option.ts"
 import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
@@ -1703,6 +1704,20 @@ function bracketPathToTokens(bracketPath: string): Array<string | number> {
     .map((part) => (INDEX_REGEXP.test(part) ? globalThis.Number(part) : part))
 }
 
+function getOrCreateContainer(
+  self: any,
+  key: PropertyKey,
+  shouldBeArray: boolean
+): any {
+  const current = Object.hasOwn(self, key) ? self[key] : undefined
+  if (current !== undefined) {
+    return current
+  }
+  const container = shouldBeArray ? [] : {}
+  internalRecord.set(self, key, container)
+  return container
+}
+
 /**
  * Builds a nested tree object from a list of bracket-path entries.
  *
@@ -1765,33 +1780,24 @@ export function makeTreeRecord<A>(
           const next = tokens[i + 1]
           const shouldBeArray = typeof next === "number" || next === ""
           const index = cur.length
-
-          if (cur[index] === undefined) {
-            cur[index] = shouldBeArray ? [] : {}
-          }
-
-          cur = cur[index]
+          cur = getOrCreateContainer(cur, index, shouldBeArray)
         }
       } else if (isLast) {
         // If we're setting a value at a path that already exists
         // convert it to an array to support multiple values for the same key
-        if (Array.isArray(cur[token])) {
+        const hasOwn = Object.hasOwn(cur, token)
+        if (hasOwn && Array.isArray(cur[token])) {
           cur[token].push(value)
-        } else if (Object.prototype.hasOwnProperty.call(cur, token)) {
-          cur[token] = [cur[token], value]
+        } else if (hasOwn) {
+          internalRecord.set(cur, token, [cur[token], value])
         } else {
-          cur[token] = value
+          internalRecord.set(cur, token, value)
         }
       } else {
         const next = tokens[i + 1]
         // if next is a number OR "" (from []), we are building an array
         const shouldBeArray = typeof next === "number" || next === ""
-
-        if (cur[token] === undefined) {
-          cur[token] = shouldBeArray ? [] : {}
-        }
-
-        cur = cur[token]
+        cur = getOrCreateContainer(cur, token, shouldBeArray)
       }
     })
   })