effect 4.0.0-beta.105 → 4.0.0-beta.106

package/src/SchemaAST.ts

@@ -16,7 +16,7 @@ import * as Cause from "./Cause.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import { format, formatPropertyKey } from "./Formatter.ts"
-import { identity, memoize } from "./Function.ts"
+import { identity, memoize, memoizeIdempotent } from "./Function.ts"
 import { effectIsExit, iterateEager } from "./internal/effect.ts"
 import * as InternalRecord from "./internal/record.ts"
 import * as InternalAnnotations from "./internal/schema/annotations.ts"
@@ -2517,7 +2517,7 @@ export type Sentinel = {
   readonly literal: LiteralValue | symbol
 }
 
-const toCandidate = memoize((ast: AST): AST => {
+const toCandidate = memoizeIdempotent((ast: AST): AST => {
   while (true) {
     if (isSuspend(ast)) return unknown
     const encoding = ast.encoding
@@ -2581,7 +2581,7 @@ function getCandidateTypes(ast: AST): ReadonlyArray<Type> {
 }
 
 /** @internal */
-export function collectSentinels(ast: AST): Array<Sentinel> {
+export function collectSentinels(ast: AST): ReadonlyArray<Sentinel> {
   switch (ast._tag) {
     default:
       return []
@@ -3280,6 +3280,13 @@ function modifyOwnPropertyDescriptors<A extends AST>(
   return Object.create(Object.getPrototypeOf(ast), d)
 }
 
+const contextOwners = new WeakMap<AST, AST>()
+
+/** @internal */
+export function getContextOwner(ast: AST): AST {
+  return contextOwners.get(ast) ?? ast
+}
+
 /** @internal */
 export function replaceEncoding<A extends AST>(ast: A, encoding: Encoding | undefined): A {
   if (ast.encoding === encoding) {
@@ -3295,9 +3302,15 @@ export function replaceContext<A extends AST>(ast: A, context: Context | undefin
   if (ast.context === context) {
     return ast
   }
-  return modifyOwnPropertyDescriptors(ast, (d) => {
+  const owner = getContextOwner(ast)
+  if (owner.context === context) {
+    return owner as A
+  }
+  const out = modifyOwnPropertyDescriptors(ast, (d) => {
     d.context.value = context
   })
+  contextOwners.set(out, owner)
+  return out
 }
 
 /** @internal */
@@ -3365,6 +3378,21 @@ export function applyToSelfOrLastLinkEncoding(f: (ast: AST) => AST) {
   return memoize(out)
 }
 
+/** @internal */
+export function applyToSelfOrLastLinkEncodingIdempotent(
+  f: (ast: AST) => AST,
+  options?: { readonly stopAt?: (link: Link) => boolean }
+) {
+  function out(ast: AST): AST {
+    if (ast.encoding) {
+      const last = ast.encoding[ast.encoding.length - 1]
+      return options?.stopAt?.(last) ? ast : replaceEncoding(ast, updateLastLink(ast.encoding, out))
+    }
+    return f(ast)
+  }
+  return memoizeIdempotent(out)
+}
+
 /** @internal */
 export function middlewareDecoding(
   ast: AST,
@@ -3432,42 +3460,34 @@ export function annotateKey<A extends AST>(ast: A, annotations: Schema.Annotatio
   return replaceContext(ast, context)
 }
 
-const optionalKeyLastLink = applyToLastLink(optionalKey)
-
-/**
- * Marks an AST node's property key as optional by setting
- * {@link Context.isOptional} to `true`.
- *
- * **Details**
- *
- * Also propagates the optional flag through the last link of the encoding
- * chain if present.
- *
- * @see {@link isOptional}
- * @see {@link Context}
- * @category transforming
- * @since 4.0.0
- */
-export function optionalKey<A extends AST>(ast: A): A {
+/** @internal */
+export const optionalKey: <A extends AST>(ast: A) => A = memoizeIdempotent(<A extends AST>(ast: A): A => {
   const context = ast.context ?
     ast.context.isOptional === false ?
       new Context(true, ast.context.isMutable, ast.context.constructorDefault, ast.context.annotations) :
       ast.context :
     new Context(true, false)
   return optionalKeyLastLink(replaceContext(ast, context))
-}
+})
 
-const mutableKeyLastLink = applyToLastLink(mutableKey)
+const optionalKeyLastLink = applyToLastLink(optionalKey)
+
+/** @internal */
+export const optional = memoize(<A extends AST>(ast: A): Union<A | Undefined> =>
+  optionalKey(new Union([ast, undefined_], "anyOf"))
+)
 
 /** @internal */
-export function mutableKey<A extends AST>(ast: A): A {
+export const mutableKey = memoizeIdempotent(<A extends AST>(ast: A): A => {
   const context = ast.context ?
     ast.context.isMutable === false ?
       new Context(ast.context.isOptional, true, ast.context.constructorDefault, ast.context.annotations) :
       ast.context :
     new Context(false, true)
   return mutableKeyLastLink(replaceContext(ast, context))
-}
+})
+
+const mutableKeyLastLink = applyToLastLink(mutableKey)
 
 /** @internal */
 export function withConstructorDefault<A extends AST>(
@@ -3616,7 +3636,7 @@ function extractStructuralChecks(checks: Checks): Checks | undefined {
  * @category transforming
  * @since 4.0.0
  */
-export const toType = memoize(<A extends AST>(ast: A): A => {
+export const toType = memoizeIdempotent(<A extends AST>(ast: A): A => {
   if (ast.encoding) {
     return toType(replaceEncoding(ast, undefined))
   }
@@ -3663,7 +3683,7 @@ export const toType = memoize(<A extends AST>(ast: A): A => {
  * @category transforming
  * @since 4.0.0
  */
-export const toEncoded = memoize((ast: AST): AST => {
+export const toEncoded = memoizeIdempotent((ast: AST): AST => {
   return toType(flip(ast))
 })
 
@@ -3807,7 +3827,7 @@ export const enumsToLiterals = memoize((ast: Enum): Union<Literal> => {
   )
 })
 
-const parameterFromPropertyKey = applyToSelfOrLastLinkEncoding((ast) => {
+const parameterFromPropertyKey = applyToSelfOrLastLinkEncodingIdempotent((ast) => {
   switch (ast._tag) {
     default:
       return ast
@@ -3819,7 +3839,7 @@ const parameterFromPropertyKey = applyToSelfOrLastLinkEncoding((ast) => {
 })
 
 /** @internal */
-export const parameterFromString = applyToSelfOrLastLinkEncoding((ast) => {
+export const parameterFromString = applyToSelfOrLastLinkEncodingIdempotent((ast) => {
   switch (ast._tag) {
     default:
       return ast
@@ -3831,7 +3851,7 @@ export const parameterFromString = applyToSelfOrLastLinkEncoding((ast) => {
   }
 })
 
-const partFromString = applyToSelfOrLastLinkEncoding((ast) => {
+const partFromString = applyToSelfOrLastLinkEncodingIdempotent((ast) => {
   switch (ast._tag) {
     default:
       return ast

package/src/SchemaRepresentation.ts

@@ -55,7 +55,13 @@ export declare namespace ToJsonSchema {
   }
 
   /**
-   * JSON Schema compiler for a check.
+   * Compiles a check to a JSON Schema fragment.
+   *
+   * **Gotchas**
+   *
+   * Treat the input schemas as immutable. The returned value must be a valid JSON Schema object graph and must not be
+   * mutated after this function returns. Return a new object graph to produce different output during a later
+   * compilation.
    *
    * @category models
    * @since 4.0.0
@@ -728,7 +734,10 @@ export function toMultiDocument(document: Document): MultiDocument {
  *
  * **Gotchas**
  *
- * Opaque declarations are represented by an unconstrained JSON Schema. Check callback results are used directly, and exceptions raised by a callback pass through unchanged.
+ * Opaque declarations are represented by an unconstrained JSON Schema. Check callback results are used directly, and
+ * exceptions raised by a callback pass through unchanged. Callbacks must treat their input schemas as immutable. Each
+ * returned value must be a valid JSON Schema object graph and must not be mutated after the callback returns. Local
+ * definition references returned by callbacks are resolved together with compiler-generated references.
  *
  * @see {@link toJsonSchemaMultiDocument} for multiple roots sharing definitions
  *
@@ -751,7 +760,10 @@ export function toJsonSchemaDocument(
  *
  * **Gotchas**
  *
- * Every definition is compiled, including definitions that are not reachable from a root.
+ * Every definition is compiled, including definitions that are not reachable from a root. Check callbacks must treat
+ * their input schemas as immutable. Each returned value must be a valid JSON Schema object graph and must not be
+ * mutated after the callback returns. Local definition references returned by callbacks are resolved together with
+ * compiler-generated references.
  *
  * @see {@link toJsonSchemaDocument} for a single root
  *

package/src/ScopedRef.ts

@@ -219,7 +219,9 @@ export const set: {
         Scope.provide(scope),
         Effect.tapCause((cause) => Scope.close(scope, Exit.failCause(cause)))
       )
-      yield* Scope.close(self.backing.backing.ref.current[0], Exit.void)
+      yield* Scope.close(self.backing.backing.ref.current[0], Exit.void).pipe(
+        Effect.tapCause((cause) => Scope.close(scope, Exit.failCause(cause)))
+      )
       self.backing.backing.ref.current = [scope, value]
     },
     Effect.uninterruptible,

package/src/TxQueue.ts

@@ -1700,7 +1700,7 @@ export const clear = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<Array<A>, Excl
  */
 export const shutdown = <A, E>(self: TxEnqueue<A, E>): Effect.Effect<boolean> =>
   Effect.gen(function*() {
-    yield* Effect.ignore(clear(self))
+    yield* Effect.ignoreCause(clear(self))
     return yield* interrupt(self)
   }).pipe(Effect.tx)
 

package/src/internal/effect.ts

@@ -822,7 +822,7 @@ export const fiberJoin = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<A, E> =>
 /** @internal */
 export const fiberJoinAll = <A extends Iterable<Fiber.Fiber<any, any>>>(self: A): Effect.Effect<
   Arr.ReadonlyArray.With<A, A extends Iterable<Fiber.Fiber<infer _A, infer _E>> ? _A : never>,
-  A extends Fiber.Fiber<infer _A, infer _E> ? _E : never
+  A extends Iterable<Fiber.Fiber<infer _A, infer _E>> ? _E : never
 > =>
   callback((resume) => {
     const fibers = Array.from(self)
@@ -5862,11 +5862,8 @@ export const useSpan: {
   return withFiber((fiber) => {
     const span = makeSpanUnsafe(fiber, name, options)
     const clock = fiber.getRef(ClockRef)
-    return onExit(internalCall(() => evaluate(span)), (exit) =>
-      sync(() => {
-        if (span.status._tag === "Ended") return
-        span.end(clock.currentTimeNanosUnsafe(), exit)
-      }))
+    const timingEnabled = fiber.getRef(TracerTimingEnabled)
+    return onExit(internalCall(() => evaluate(span)), (exit) => endSpan(span, exit, clock, timingEnabled))
   })
 }
 

package/src/internal/executionPlan.ts

@@ -31,6 +31,7 @@ export const makeEventEmitter = (
 ): EventEmitter => {
   let lastStepIndex = -1
   let stepAttempt = 0
+  const emit = (event: Api.Event<any>) => effect.ignoreCause(onEvent(event))
   return {
     begin: effect.clockWith((clock) =>
       effect.suspend(() => {
@@ -47,7 +48,7 @@ export const makeEventEmitter = (
           startNanos: clock.monotonicTimeNanosUnsafe()
         }
         return effect.as(
-          onEvent({
+          emit({
             _tag: "AttemptStart",
             attempt: state.attempt,
             stepAttempt: state.stepAttempt,
@@ -60,7 +61,7 @@ export const makeEventEmitter = (
     end: (state, exit) =>
       effect.clockWith((clock) => {
         const duration = Duration.nanos(clock.monotonicTimeNanosUnsafe() - state.startNanos)
-        return onEvent(
+        return emit(
           exit._tag === "Success"
             ? {
               _tag: "AttemptSuccess",

package/src/internal/rcRef.ts

@@ -94,7 +94,7 @@ export const make = <A, E, R>(options: {
   })
 
 const getState = <A, E>(self: RcRefImpl<A, E>) =>
-  Effect.uninterruptibleMask((restore) => {
+  Effect.uninterruptibleMask(function loop(restore): Effect.Effect<State.Acquired<A>, E> {
     switch (self.state._tag) {
       case "Closed": {
         return Effect.interrupt
@@ -107,22 +107,30 @@ const getState = <A, E>(self: RcRefImpl<A, E>) =>
       }
       case "Empty": {
         const scope = Scope.makeUnsafe()
-        return self.semaphore.withPermits(1)(
-          restore(Effect.provideContext(
-            self.acquire as Effect.Effect<A, E>,
-            Context.add(self.context, Scope.Scope, scope)
-          )).pipe(Effect.map((value) => {
-            const state: State.Acquired<A> = {
-              _tag: "Acquired",
-              value,
-              scope,
-              fiber: undefined,
-              refCount: 1,
-              invalidated: false
+        return self.semaphore.withPermit(
+          Effect.suspend(() => {
+            if (self.state._tag !== "Empty") {
+              return loop(restore)
             }
-            self.state = state
-            return state
-          }))
+            return restore(Effect.provideContext(
+              self.acquire as Effect.Effect<A, E>,
+              Context.add(self.context, Scope.Scope, scope)
+            )).pipe(
+              Effect.map((value) => {
+                const state: State.Acquired<A> = {
+                  _tag: "Acquired",
+                  value,
+                  scope,
+                  fiber: undefined,
+                  refCount: 1,
+                  invalidated: false
+                }
+                self.state = state
+                return state
+              }),
+              Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)
+            )
+          })
         )
       }
     }

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -757,23 +757,26 @@ function translateJsonSchemaMultiDocument(
       case "boolean":
         return { _tag: "Boolean", checks: [] }
       case "array": {
+        const prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems : undefined
         const minItems = typeof schema.minItems === "number" ? schema.minItems : 0
-        const elements = Array.isArray(schema.prefixItems)
-          ? schema.prefixItems.map((element, index) => ({
-            isOptional: index + 1 > minItems,
-            type: recur(element, [...path, "prefixItems", index])
-          }))
-          : []
-        const rest = schema.items !== undefined
-          ? [recur(schema.items, [...path, "items"])]
-          : schema.prefixItems !== undefined && typeof schema.maxItems === "number"
-          ? []
-          : [unknown]
+        const elements = prefixItems?.map((element, index) => ({
+          isOptional: index + 1 > minItems,
+          type: recur(element, [...path, "prefixItems", index])
+        })) ?? []
+        const isTupleClosed = schema.items === false ||
+          (schema.items === undefined &&
+            prefixItems !== undefined &&
+            schema.maxItems === prefixItems.length)
+        const isMaxItemsRedundant = isTupleClosed &&
+          typeof schema.maxItems === "number" &&
+          schema.maxItems >= elements.length
         return {
           _tag: "Arrays",
           elements,
-          rest,
-          checks: collectArrayChecks(schema)
+          rest: isTupleClosed
+            ? []
+            : [schema.items === undefined ? unknown : recur(schema.items, [...path, "items"])],
+          checks: collectArrayChecks(schema, isMaxItemsRedundant)
         }
       }
       case "object":
@@ -808,10 +811,12 @@ function translateJsonSchemaMultiDocument(
     return checks
   }
 
-  function collectArrayChecks(schema: JsonSchema.JsonSchema): Array<Check> {
+  function collectArrayChecks(schema: JsonSchema.JsonSchema, isMaxItemsRedundant: boolean): Array<Check> {
     const checks: Array<Check> = []
     if (schema.prefixItems === undefined) {
       addNumberCheck(checks, schema.minItems, "effect/schema/isMinLength", "minLength")
+    }
+    if (!isMaxItemsRedundant) {
       addNumberCheck(checks, schema.maxItems, "effect/schema/isMaxLength", "maxLength")
     }
     if (schema.uniqueItems === true) {

package/src/internal/schema/toArbitrary.ts

@@ -34,20 +34,6 @@ type LazyOption<T> = (
   recursionStack: RecursionStack
 ) => FastCheck.Arbitrary<T> | undefined
 
-export interface MutableReport {
-  readonly warnings: Array<Schema.Annotations.ToArbitrary.Warning>
-}
-
-/** @internal */
-export function makeReport(): MutableReport {
-  return { warnings: [] }
-}
-
-/** @internal */
-export function toReport(report: MutableReport): Schema.Annotations.ToArbitrary.Report {
-  return { warnings: report.warnings.slice() }
-}
-
 function arbitraryError(what: string) {
   return new Error(`Unable to derive an arbitrary for ${what}`)
 }
@@ -394,64 +380,6 @@ function finiteNumberContext(ctx: Context): Context {
   }
 }
 
-function reportChecks(report: MutableReport, checks: SchemaAST.Checks | undefined, path: ReadonlyArray<PropertyKey>) {
-  function visit(check: SchemaAST.Check<any>, covered: boolean) {
-    const arbitrary = check.annotations?.arbitrary
-    const nextCovered = covered || arbitrary?.constraint !== undefined || arbitrary?.candidate !== undefined
-    if (check._tag !== "Filter") {
-      for (const child of check.checks) {
-        visit(child, nextCovered)
-      }
-    } else if (!nextCovered) {
-      const description = check.annotations?.representation?.id ?? check.annotations?.identifier ??
-        check.annotations?.expected
-      report.warnings.push({ _tag: "OpaqueFilter", path, ...(description === undefined ? {} : { description }) })
-    }
-  }
-  checks?.forEach((check) => visit(check, false))
-}
-
-/** @internal */
-export function collectReport(ast: SchemaAST.AST, report: MutableReport) {
-  const stack = new WeakSet<SchemaAST.AST>()
-  function visit(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>) {
-    if (stack.has(ast)) {
-      return
-    }
-    stack.add(ast)
-    reportChecks(report, ast.checks, path)
-    switch (ast._tag) {
-      case "Declaration":
-        ast.typeParameters.forEach((tp) => visit(tp, path))
-        break
-      case "Arrays": {
-        for (const [i, type] of [...ast.elements, ...ast.rest].entries()) {
-          visit(type, [...path, i])
-        }
-        break
-      }
-      case "Objects":
-        ast.propertySignatures.forEach((ps) => visit(ps.type, [...path, ps.name]))
-        ast.indexSignatures.forEach((is) => {
-          visit(is.parameter, path)
-          visit(is.type, path)
-        })
-        break
-      case "Union":
-        ast.types.forEach((type) => visit(type, path))
-        break
-      case "TemplateLiteral":
-        ast.parts.forEach((part, i) => visit(SchemaAST.toEncoded(part), [...path, i]))
-        break
-      case "Suspend":
-        visit(ast.thunk(), path)
-        break
-    }
-    stack.delete(ast)
-  }
-  visit(ast, [])
-}
-
 function applyCandidates(
   fc: typeof FastCheck,
   ctx: Context,

package/src/internal/schema/toJsonSchemaDocument.ts

@@ -1,7 +1,8 @@
 import * as Arr from "../../Array.ts"
 import * as Equal from "../../Equal.ts"
-import { escapeToken } from "../../JsonPointer.ts"
+import { escapeToken, 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"
@@ -21,6 +22,11 @@ const jsonSchemaAnnotationExcludedKeys = new Set([
   ...InternalAnnotations.jsonSchemaAnnotationKeys
 ])
 
+/** @internal */
+export const toRepresentationOptions = {
+  isAnonymousReferenceAllowed: (ast: SchemaAST.AST): boolean => !SchemaAST.isDeclaration(ast)
+}
+
 function collectJsonSchemaAnnotations(
   annotations: Schema.Annotations.Annotations | undefined,
   options: Schema.ToJsonSchemaOptions | undefined
@@ -142,22 +148,26 @@ function compileJsonSchema(
   references: SchemaRepresentation.References,
   options: Schema.ToJsonSchemaOptions | undefined
 ): JsonSchema.MultiDocument<"draft-2020-12"> {
-  const definitions: Record<string, JsonSchema.JsonSchema> = {}
   // null = compiling, string = canonical key, object = compiled schema
   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])
   }
+  const schemas = Arr.map(
+    representations,
+    (representation, index) => finalizeJsonSchema(recur(representation, rootPaths[index]))
+  )
+  const definitions: Record<string, JsonSchema.JsonSchema> = {}
   for (const key of referenceKeys) {
     const compiled = definitionStates.get(key)!
     if (typeof compiled !== "string") {
-      InternalRecord.assignProperty(definitions, key, compiled)
+      InternalRecord.assignProperty(definitions, key, finalizeJsonSchema(compiled))
     }
   }
-  const schemas = Arr.map(representations, (representation, index) => recur(representation, rootPaths[index]))
   return { dialect: "draft-2020-12", schemas, definitions }
 
   function compileDefinition(key: string, path: Path): string {
@@ -179,6 +189,7 @@ function compileJsonSchema(
         if (candidates === undefined) fallbackDefinitions.set(fallback, [key])
         else candidates.push(key)
       } else {
+        hasAliases = true
         definitionStates.set(key, match)
         return match
       }
@@ -187,6 +198,15 @@ function compileJsonSchema(
     return key
   }
 
+  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
+      }))
+  }
+
   function getIdentifierFallback(
     representation: SchemaRepresentation.Representation
   ): string | undefined {