effect 4.0.0-rc.118 → 4.0.1

package/src/SchemaAST.ts

@@ -3394,7 +3394,8 @@ export function collectSentinels(ast: AST): ReadonlyArray<Sentinel> {
   }
 }
 
-type CandidateIndex = (input: any, isConstructor: boolean) => ReadonlyArray<AST>
+/** @internal */
+export type CandidateIndex = (input: any, isConstructor: boolean) => ReadonlyArray<number>
 type SentinelEntry = readonly [
   byValue: Map<LiteralValue | symbol, Set<number>>,
   all: Set<number>
@@ -3409,15 +3410,17 @@ const getRuntimeType = (input: unknown): Type => input === null ? "null" : Array
 const hasPropertySignature = (input: object, key: PropertyKey): boolean =>
   key === "__proto__" ? Object.hasOwn(input, key) : key in input
 
-function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
+/** @internal */
+export function getCandidateIndex(types: ReadonlyArray<AST>): CandidateIndex {
   let index = candidateIndexCache.get(types)
   if (index) return index
 
   let bySentinel: SentinelIndex | undefined
   let sentinelCandidateCount = 0
   let otherwise: { [K in Type]?: Array<number> } | undefined
-  let literalCandidates: Map<LiteralValue | symbol, Array<AST>> | undefined
+  let literalCandidates: Map<LiteralValue | symbol, Array<number>> | undefined
   let onlyLiterals = true
+  const literalOf: Array<LiteralValue | symbol | undefined> = []
   for (let i = 0; i < types.length; i++) {
     const a = types[i]
     const encoded = toCandidate(a)
@@ -3426,9 +3429,10 @@ function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
     if (isLiteral(encoded) || isUniqueSymbol(encoded)) {
       literalCandidates ??= new Map()
       const literal = isLiteral(encoded) ? encoded.literal : encoded.symbol
+      literalOf[i] = literal
       let arr = literalCandidates.get(literal)
       if (!arr) literalCandidates.set(literal, arr = [])
-      arr.push(a)
+      arr.push(i)
     } else {
       onlyLiterals = false
     }
@@ -3454,24 +3458,25 @@ function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
   }
 
   // Non-discriminated members are grouped by runtime type once and reused by every decode.
-  const fallbacks: { [K in Type]?: ReadonlyArray<AST> } = {}
-  const getFallback = (type: Type): ReadonlyArray<AST> =>
-    fallbacks[type] ??= Object.freeze((otherwise?.[type] ?? emptyCandidates).map((i) => types[i]))
+  const fallbacks: { [K in Type]?: ReadonlyArray<number> } = {}
+  const getFallback = (type: Type): ReadonlyArray<number> =>
+    fallbacks[type] ??= Object.freeze(otherwise?.[type] ?? emptyCandidates)
 
   if (onlyLiterals && literalCandidates) {
     literalCandidates.forEach(Object.freeze)
     index = (input) => literalCandidates.get(input) ?? emptyCandidates
   } else if (bySentinel?.size === 1 && !otherwise) {
     const [key, [byValue]] = bySentinel.entries().next().value!
-    const candidates = byValue as unknown as Map<LiteralValue | symbol, ReadonlyArray<AST>>
+    const candidates = new Map<LiteralValue | symbol, ReadonlyArray<number>>()
     for (const [literal, indexes] of byValue) {
-      candidates.set(literal, Object.freeze(Array.from(indexes, (index) => types[index])))
+      candidates.set(literal, Object.freeze(Array.from(indexes)))
     }
+    const all = Object.freeze(types.map((_, i) => i))
     index = (input, isConstructor) => {
       if (Predicate.isObjectKeyword(input)) {
         const value = hasPropertySignature(input, key) ? (input as any)[key] : undefined
         if (value !== undefined) return candidates.get(value) ?? emptyCandidates
-        if (isConstructor) return types
+        if (isConstructor) return all
       }
       return emptyCandidates
     }
@@ -3538,12 +3543,12 @@ function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
           }
         }
       }
-      return Array.from(selected).sort((a, b) => a - b).map((i) => types[i])
+      return Array.from(selected).sort((a, b) => a - b)
     }
   } else {
     index = (input) => {
       const fallback = getFallback(getRuntimeType(input))
-      return literalCandidates ? fallback.filter(filterLiterals(input)) : fallback
+      return literalCandidates ? fallback.filter((i) => literalOf[i] === undefined || literalOf[i] === input) : fallback
     }
   }
 
@@ -3551,31 +3556,6 @@ function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
   return index
 }
 
-function filterLiterals(input: any) {
-  return (ast: AST) => {
-    const encoded = toCandidate(ast)
-    return encoded._tag === "Literal" ?
-      encoded.literal === input
-      : encoded._tag === "UniqueSymbol" ?
-      encoded.symbol === input
-      : true
-  }
-}
-
-/**
- * The goal is to reduce the number of a union members that will be checked.
- * This is useful to reduce the number of issues that will be returned.
- *
- * @internal
- */
-export function getCandidates(
-  input: any,
-  types: ReadonlyArray<AST>,
-  isConstructor = false
-): ReadonlyArray<AST> {
-  return getIndex(types)(input, isConstructor)
-}
-
 /**
  * AST node representing a union of schemas.
  *
@@ -3680,43 +3660,28 @@ export const Union: new<A extends AST = AST>(
   ): SchemaParser.Parser {
     // oxlint-disable-next-line @typescript-eslint/no-this-alias
     const ast = this
+    const isConstructor = compileField !== undefined
+    const parsers: Array<SchemaParser.Parser> = []
+    const parser = (i: number): SchemaParser.Parser => parsers[i] ??= compile(ast.types[i])
+    let index: CandidateIndex | undefined
 
     return (input, options) => {
       if (input === InternalParser.missing) {
         return InternalParser.missingExit
       }
-      const candidates = getCandidates(input, ast.types, compileField !== undefined)
+      const candidates = (index ??= getCandidateIndex(ast.types))(input, isConstructor)
 
       if (candidates.length === 0) {
         return Effect.fail(new SchemaIssue.AnyOf(ast, [], input, options))
       }
       if (candidates.length === 1) {
-        const result = compile(candidates[0])(input, options)
+        const result = parser(candidates[0])(input, options)
         if ((result as Exit.Exit<unknown, SchemaIssue.Issue>)._tag === "Success") return result
         return effectIsExit(result)
           ? failSingleUnionCandidate(ast, (result as Exit.Failure<unknown, SchemaIssue.Issue>).cause, input, options)
-          : Effect.catchCause(result, (cause) => failSingleUnionCandidate(ast, cause, input, options))
-      }
-
-      const state = {
-        ast,
-        compile,
-        input,
-        out: undefined,
-        successes: ast.options?.mode === "oneOf" ? [] : undefined,
-        issues: undefined as Arr.NonEmptyArray<SchemaIssue.Issue> | undefined,
-        options
-      }
-      const eff = parseUnion(state, candidates)
-      if (!eff) {
-        if (state.out) return state.out
-        return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options))
+          : catchSingleUnionCandidate(ast, result, input, options)
       }
-      return Effect.flatMapEager(eff, (_) => {
-        if (state.out === InternalParser.sameExit) return Effect.succeed(input)
-        if (state.out) return state.out
-        return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options))
-      })
+      return parseUnionCandidates(ast, parser, candidates, input, options)
     }
   }
   private _rebuild(
@@ -3795,20 +3760,65 @@ function failSingleUnionCandidate(
   return Exit.fail(new SchemaIssue.AnyOf(ast, [issue], input, options))
 }
 
-const parseUnion = iterateEager<{
-  readonly compile: (ast: AST) => SchemaParser.Parser
+function catchSingleUnionCandidate(
+  ast: Union,
+  result: Effect.Effect<unknown, SchemaIssue.Issue, unknown>,
+  input: unknown,
+  options: ParseOptions
+) {
+  return Effect.catchCause(result, (cause) => failSingleUnionCandidate(ast, cause, input, options))
+}
+
+type UnionParserState = {
+  readonly parser: (i: number) => SchemaParser.Parser
   readonly ast: Union
   readonly input: unknown
   readonly options: ParseOptions
   out: Exit.Success<unknown, SchemaIssue.Issue> | undefined
   readonly successes: Array<AST> | undefined
   issues: Array<SchemaIssue.Issue> | undefined
-}, AST>()({
-  onItem(s, ast) {
-    const parser = s.compile(ast)
-    return parser(s.input, s.options)
+}
+
+function parseUnionCandidates(
+  ast: Union,
+  parser: (i: number) => SchemaParser.Parser,
+  candidates: ReadonlyArray<number>,
+  input: unknown,
+  options: ParseOptions
+): Effect.Effect<unknown, SchemaIssue.Issue, any> {
+  const state: UnionParserState = {
+    ast,
+    parser,
+    input,
+    out: undefined,
+    successes: ast.options?.mode === "oneOf" ? [] : undefined,
+    issues: undefined,
+    options
+  }
+  const eff = parseUnion(state, candidates)
+  if (!eff) {
+    if (state.out) return state.out
+    return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options))
+  }
+  return resumeUnion(eff, state)
+}
+
+function resumeUnion(
+  eff: Effect.Effect<void, SchemaIssue.Issue, any>,
+  state: UnionParserState
+): Effect.Effect<unknown, SchemaIssue.Issue, any> {
+  return Effect.flatMapEager(eff, (_) => {
+    if (state.out === InternalParser.sameExit) return Effect.succeed(state.input)
+    if (state.out) return state.out
+    return Effect.fail(new SchemaIssue.AnyOf(state.ast, state.issues ?? [], state.input, state.options))
+  })
+}
+
+const parseUnion = iterateEager<UnionParserState, number>()({
+  onItem(s, i) {
+    return s.parser(i)(s.input, s.options)
   },
-  step(s, candidate, exit) {
+  step(s, i, exit) {
     if (exit._tag === "Failure") {
       const issue = InternalSchemaCause.getSchemaIssue(exit.cause)
       if (issue === undefined) {
@@ -3818,12 +3828,12 @@ const parseUnion = iterateEager<{
       else s.issues = [issue]
     } else {
       if (s.out && s.successes) {
-        s.successes.push(candidate)
+        s.successes.push(s.ast.types[i])
         return Exit.fail(new SchemaIssue.OneOf(s.ast, s.successes, s.input, s.options))
       }
       s.out = exit
       if (s.successes) {
-        s.successes.push(candidate)
+        s.successes.push(s.ast.types[i])
       } else {
         return Exit.void
       }
@@ -4220,26 +4230,33 @@ export function isPattern(regExp: globalThis.RegExp, annotations?: Schema.Annota
   )
 }
 
-function copy<A extends AST>(ast: A): Types.Mutable<A> {
+// Copies that update only context or encoding share a body.
+// All other fields describe the body itself, including child contexts.
+const bodyOwners = new WeakMap<AST, AST>()
+
+function copy<A extends AST>(ast: A, changes: Partial<AST>): A {
   // AST copies preserve the prototype and enumerable values, not property descriptors.
-  return Object.assign(Object.create(Object.getPrototypeOf(ast)), ast)
+  const out = Object.assign(Object.create(Object.getPrototypeOf(ast)), ast, changes) as A
+  if (Reflect.ownKeys(changes).every((key) => key === "context" || key === "encoding")) {
+    bodyOwners.set(out, getContextOwner(ast))
+  }
+  return out
 }
 
-const contextOwners = new WeakMap<AST, AST>()
-
 /** @internal */
-export function getContextOwner(ast: AST): AST {
-  return contextOwners.get(ast) ?? ast
+export function getContextOwner<A extends AST>(ast: A): A {
+  const existing = bodyOwners.get(ast)
+  if (existing !== undefined) return existing as A
+  if (ast.encoding === undefined) return ast
+  // A body representative must not expose or retain the node's own codec.
+  const owner = Object.assign(Object.create(Object.getPrototypeOf(ast)), ast, { encoding: undefined }) as A
+  bodyOwners.set(ast, owner)
+  return owner
 }
 
 /** @internal */
 export function replaceEncoding<A extends AST>(ast: A, encoding: Encoding | undefined): A {
-  if (ast.encoding === encoding) {
-    return ast
-  }
-  const out = copy(ast)
-  out.encoding = encoding
-  return out
+  return ast.encoding === encoding ? ast : copy(ast, { encoding })
 }
 
 /** @internal */
@@ -4248,13 +4265,10 @@ export function replaceContext<A extends AST>(ast: A, context: Context | undefin
     return ast
   }
   const owner = getContextOwner(ast)
-  if (owner.context === context) {
-    return owner as A
+  if (owner.context === context && owner.encoding === ast.encoding) {
+    return owner
   }
-  const out = copy(ast)
-  out.context = context
-  contextOwners.set(out as A, owner)
-  return out
+  return copy(ast, { context })
 }
 
 /** @internal */
@@ -4268,9 +4282,7 @@ export function annotate<A extends AST>(ast: A, annotations: Schema.Annotations.
     const last = ast.checks[ast.checks.length - 1]
     return replaceChecks(ast, Arr.append(ast.checks.slice(0, -1), last.annotate(annotations)))
   }
-  const out = copy(ast)
-  out.annotations = { ...ast.annotations, ...annotations }
-  return out
+  return copy(ast, { annotations: { ...ast.annotations, ...annotations } })
 }
 
 /** @internal */
@@ -4281,9 +4293,7 @@ export function replaceChecks<A extends AST>(ast: A, checks: Checks | undefined)
   if (ast.checks === checks) {
     return ast
   }
-  const out = copy(ast)
-  out.checks = checks
-  return out
+  return copy(ast, { checks })
 }
 
 /** @internal */
@@ -4364,13 +4374,6 @@ function appendTransformation<A extends AST>(
   return replaceEncoding(to, to.encoding ? [...to.encoding, link] : [link])
 }
 
-/** @internal */
-export function brand(ast: AST, brand: string): AST {
-  const existing = InternalAnnotations.resolveBrands(ast)
-  const brands = existing ? [...existing, brand] : [brand]
-  return annotate(ast, { brands })
-}
-
 /**
  * Maps over the array but will return the original array if no changes occur.
  * @internal
@@ -4555,6 +4558,17 @@ function extractStructuralChecks(checks: Checks): Checks | undefined {
   return Arr.isArrayNonEmpty(out) ? out : undefined
 }
 
+function canPreserveEncodingChecks(ast: AST): boolean {
+  let preserve = true
+  function visit(child: AST): AST {
+    preserve = preserve && !child.encoding && !isSuspend(child)
+    if (preserve && "recur" in child) child.recur(visit)
+    return child
+  }
+  if ("recur" in ast) ast.recur(visit)
+  return preserve
+}
+
 /**
  * Strips all encoding transformations from an AST, returning the decoded
  * (type-level) representation.
@@ -4581,22 +4595,24 @@ function extractStructuralChecks(checks: Checks): Checks | undefined {
  * @since 4.0.0
  */
 export const toType = memoizeIdempotent(<A extends AST>(ast: A): A => {
-  const out: any = ast
-  const type = out.recur?.(toType) ?? out
-  const encodingChecks: Checks | undefined = type.encodingChecks
-  if (encodingChecks) {
-    const checks = type === ast
-      ? encodingChecks
+  const owner = getContextOwner(ast)
+  if (owner !== ast) {
+    const type = toType(owner)
+    return type === owner && ast.encoding === undefined ? ast : replaceContext(type, ast.context)
+  }
+  const type = ("recur" in ast ? ast.recur(toType) : ast) as A
+  if ("encodingChecks" in type && type.encodingChecks) {
+    const checks = canPreserveEncodingChecks(ast)
+      ? type.encodingChecks
       : isArrays(type) || isObjects(type) || isDeclaration(type) && type.typeParameters.length > 0
-      ? extractStructuralChecks(encodingChecks)
+      ? extractStructuralChecks(type.encodingChecks)
       : undefined
-    const copyOfType = copy(type)
-    copyOfType.encoding = undefined
-    copyOfType.encodingChecks = undefined
-    copyOfType.checks = combineChecks(type.checks, checks)
-    return copyOfType
+    return copy(type, {
+      encodingChecks: undefined,
+      checks: combineChecks(type.checks, checks)
+    })
   }
-  return type.encoding ? replaceEncoding(type, undefined) : type
+  return type
 })
 
 /**
@@ -4668,8 +4684,12 @@ export const flip = memoize((ast: AST): AST => {
   if (ast.encoding) {
     return flipEncoding(ast, ast.encoding)
   }
-  const out: any = ast
-  return out.flip?.(flip) ?? out.recur?.(flip) ?? out
+  const owner = getContextOwner(ast)
+  if (owner !== ast) {
+    const flipped = flip(owner)
+    return flipped === owner ? ast : replaceContext(flipped, ast.context)
+  }
+  return "flip" in ast ? ast.flip(flip) : "recur" in ast ? ast.recur(flip) : ast
 })
 
 /** @internal */

package/src/SchemaRepresentation.ts

@@ -2432,7 +2432,9 @@ export interface ToRepresentationOptions {
  * **Details**
  *
  * Apply `SchemaAST.toType` to the AST first to lower its type side instead. The optional reference policy controls which
- * candidates are moved into the document's shared reference table.
+ * candidates are moved into the document's shared reference table. TypeScript-only
+ * distinctions such as those added by `Schema.brand` are absent from the AST
+ * and cannot be reconstructed from the resulting document.
  *
  * @see {@link toRepresentations} for multiple roots sharing one reference table
  *

package/src/ScopedCache.ts

@@ -317,7 +317,7 @@ export const get: {
           // Move the entry to the end of the map to keep it fresh
           MutableHashMap.remove(state.map, key)
           MutableHashMap.set(state.map, key, oentry.value)
-          return awaitEntry(oentry.value, restore)
+          return awaitEntry(self, key, oentry.value, restore)
         }
         const scope = Scope.makeUnsafe()
         const deferred = Deferred.makeUnsafe</**
@@ -380,41 +380,46 @@ export const get: {
             entry.fiber = effect.forkUnsafe(
               fiber,
               effect.onExit(effect.suspend(() => Scope.provide(self.lookup(key), scope)), (exit) => {
-                Deferred.doneUnsafe(deferred, exit)
                 if (effect.exitHasInterrupts(exit)) {
-                  if (self.state._tag === "Open") {
-                    const current = MutableHashMap.get(self.state.map, key)
-                    if (Option.isSome(current) && current.value === entry) MutableHashMap.remove(self.state.map, key)
-                  }
+                  removeEntry(self, key, entry)
+                  Deferred.doneUnsafe(deferred, exit)
                   return Scope.close(scope, exit)
                 }
-                const ttl = self.timeToLive(exit, key)
-                if (Duration.isFinite(ttl)) {
-                  entry.expiresAt = fiber.getRef(effect.ClockRef).currentTimeMillisUnsafe() + Duration.toMillis(ttl)
+                try {
+                  const ttl = self.timeToLive(exit, key)
+                  if (Duration.isFinite(ttl)) {
+                    entry.expiresAt = fiber.getRef(effect.ClockRef).currentTimeMillisUnsafe() + Duration.toMillis(ttl)
+                  }
+                } finally {
+                  Deferred.doneUnsafe(deferred, exit)
                 }
                 return effect.void
               }),
               true,
               true
             )
-            return awaitEntry(entry, restore)
+            return awaitEntry(self, key, entry, restore)
           })
         )
       })
     )
 )
 
-const awaitEntry = <A, E>(
+const awaitEntry = <Key, A, E, R>(
+  self: ScopedCache<Key, A, E, R>,
+  key: Key,
   entry: Entry<A, E>,
   restore: <X, Y, Z>(effect: Effect.Effect<X, Y, Z>) => Effect.Effect<X, Y, Z>
 ): Effect.Effect<A, E> => {
-  const fiber = entry.fiber
-  if (fiber === undefined || Deferred.isDoneUnsafe(entry.deferred)) return restore(Deferred.await(entry.deferred))
+  if (Deferred.isDoneUnsafe(entry.deferred)) return restore(Deferred.await(entry.deferred))
   entry.awaiters++
   // Install cleanup before restore so a pending interrupt cannot skip the decrement.
   return effect.onExit(restore(Deferred.await(entry.deferred)), () => {
     entry.awaiters--
-    if (entry.awaiters > 0 || Deferred.isDoneUnsafe(entry.deferred)) return effect.void
+    const fiber = entry.fiber
+    if (entry.awaiters > 0 || fiber === undefined || Deferred.isDoneUnsafe(entry.deferred)) return effect.void
+    // Detach before interruption so callers arriving during finalization start fresh.
+    removeEntry(self, key, entry)
     return effect.flatMap(effect.fiberInterrupt(fiber), () => {
       const exit = fiber.pollUnsafe()!
       return Exit.isFailure(exit) && Cause.hasDies(exit.cause) ? effect.failCause(exit.cause) : effect.void
@@ -422,6 +427,12 @@ const awaitEntry = <A, E>(
   })
 }
 
+const removeEntry = <Key, A, E, R>(self: ScopedCache<Key, A, E, R>, key: Key, entry: Entry<A, E>): void => {
+  if (self.state._tag !== "Open") return
+  const current = MutableHashMap.get(self.state.map, key)
+  if (Option.isSome(current) && current.value === entry) MutableHashMap.remove(self.state.map, key)
+}
+
 const hasExpired = <A, E>(entry: Entry<A, E>, fiber: Fiber.Fiber<unknown, unknown>): boolean => {
   if (entry.expiresAt === undefined) {
     return false
@@ -518,7 +529,7 @@ export const getOption: {
       core.withFiber((fiber) =>
         effect.flatMap(
           getImpl(self, key, fiber),
-          (entry) => entry ? effect.asSome(awaitEntry(entry, restore)) : effect.succeedNone
+          (entry) => entry ? effect.asSome(awaitEntry(self, key, entry, restore)) : effect.succeedNone
         )
       )
     )
@@ -1004,7 +1015,7 @@ export const invalidateWhen: {
           if (entry === undefined) {
             return effect.succeed(false)
           }
-          return awaitEntry(entry, restore).pipe(
+          return awaitEntry(self, key, entry, restore).pipe(
             effect.flatMap((value) => {
               if (self.state._tag === "Closed") {
                 return effect.succeed(false)