effect 4.0.6 → 4.0.7

package/src/http-api/OpenApi.ts

@@ -548,10 +548,13 @@ function makeOpenApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
         if (!HttpApiMiddleware.isSecurity(middleware)) {
           return
         }
-        for (const [name, security] of Object.entries(middleware.security)) {
-          processHttpApiSecurity(name, security)
-          op.security.push({ [name]: [] })
+        const names = Object.keys(middleware.security)
+        for (const name of names) {
+          processHttpApiSecurity(name, middleware.security[name])
         }
+        // Stacked middleware must all pass (AND); schemes within one middleware are alternatives (OR).
+        const requirements = op.security.length === 0 ? [{}] : op.security
+        op.security = requirements.flatMap((requirement) => names.map((name) => ({ ...requirement, [name]: [] })))
       })
 
       function processHttpApiSecurity(
@@ -585,7 +588,9 @@ function makeOpenApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
         for (const schema of HttpApiEndpoint.getPayloadSchemas(endpoint)) {
           if (HttpApiSchema.isStreamSchema(schema)) {
             // Endpoint construction rejects a buffered payload sharing a streaming payload's media type.
-            schemasByContentType.set(schema.contentType, schema)
+            for (const contentType of schema.contentTypes) {
+              schemasByContentType.set(contentType, schema)
+            }
             continue
           }
           if (HttpApiSchema.isNoContent(schema.ast)) continue
@@ -825,6 +830,9 @@ function selectReferences(
 
     pushChecks(representation.checks)
     switch (representation._tag) {
+      case "String":
+        if (representation.content?.schema !== undefined) stack.push(representation.content.schema)
+        break
       case "Declaration":
         stack.push(...representation.typeParameters)
         break
@@ -899,6 +907,7 @@ function extractResponseBodies(
       map.get(status)!.headers.push(
         Schema.Struct({ connection: Schema.Literal("Upgrade"), upgrade: Schema.Literal(body.protocol) })
       )
+      if (body.headers !== undefined) map.get(status)!.headers.push(body.headers)
     } else if (HttpApiSchema.isStreamSchema(body)) {
       addStreamContent(body, status)
     } else if (HttpApiSchema.isNoContent(ast)) {
@@ -975,20 +984,14 @@ function extractResponseBodies(
     stream: HttpApiSchema.StreamSchema,
     status: number
   ) {
-    const statusMap = map.get(status)
+    let statusMap = map.get(status)
     if (statusMap === undefined) {
-      map.set(status, {
-        descriptions: new Set(),
-        content: undefined,
-        headers: [],
-        streamContent: new Map([[stream.contentType, stream]])
-      })
-    } else {
-      if (statusMap.streamContent === undefined) {
-        statusMap.streamContent = new Map([[stream.contentType, stream]])
-      } else {
-        statusMap.streamContent.set(stream.contentType, stream)
-      }
+      statusMap = { descriptions: new Set(), content: undefined, headers: [], streamContent: undefined }
+      map.set(status, statusMap)
+    }
+    const streamContent = statusMap.streamContent ??= new Map()
+    for (const contentType of stream.contentTypes) {
+      streamContent.set(contentType, stream)
     }
   }
 }

package/src/http-api/internal/toCodecHttpProperties.ts

@@ -0,0 +1,56 @@
+import { memoize } from "../../Function.ts"
+import * as Option from "../../Option.ts"
+import * as Predicate from "../../Predicate.ts"
+import * as Schema from "../../Schema.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
+import * as SchemaGetter from "../../SchemaGetter.ts"
+import * as SchemaTransformation from "../../SchemaTransformation.ts"
+
+/** @internal */
+export function toCodecHttpProperties<S extends Schema.Constraint>(schema: S): Schema.toCodecStringTree<S> {
+  const codec = Schema.toCodecStringTree(schema)
+  return codec.rebuild(normalizeProperties(codec.ast))
+}
+
+const omitUndefined = new SchemaTransformation.Transformation(
+  SchemaGetter.passthrough(),
+  SchemaGetter.transformOptional(Option.filter(Predicate.isNotUndefined))
+)
+
+// Only descend through unions and suspensions, leaving nested values alone.
+const present = memoize((ast: SchemaAST.AST): SchemaAST.AST => {
+  if (ast._tag === "Undefined") return new SchemaAST.Never(ast.annotations, undefined, undefined, ast.context)
+  if (ast._tag === "Suspend") return ast.recur(present)
+  if (ast._tag !== "Union") return ast
+
+  const members = SchemaAST.mapOrSame(ast.types, present)
+  if (members === ast.types) return ast
+  const types = members.filter((member) => member._tag !== "Never")
+  if (types.length === 1 && ast.checks === undefined && ast.annotations === undefined) {
+    return SchemaAST.replaceContext(types[0], ast.context)
+  }
+  return new SchemaAST.Union(types, ast.options, ast.annotations, ast.checks, undefined, ast.context)
+})
+
+const normalizeProperties = SchemaAST.applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+  if (ast._tag === "Union" || ast._tag === "Suspend") return ast.recur(normalizeProperties)
+  if (ast._tag !== "Objects") return ast
+
+  const properties = SchemaAST.mapOrSame(ast.propertySignatures, (ps) => {
+    const encoded = SchemaAST.toEncoded(ps.type)
+    if (!SchemaAST.isOptional(encoded)) return ps
+    const wire = present(encoded)
+    return wire === encoded
+      ? ps
+      : new SchemaAST.PropertySignature(ps.name, SchemaAST.decodeTo(wire, ps.type, omitUndefined))
+  })
+  return properties === ast.propertySignatures ? ast : new SchemaAST.Objects(
+    properties,
+    ast.indexSignatures,
+    ast.annotations,
+    ast.checks,
+    undefined,
+    ast.context,
+    ast.encodingChecks
+  )
+})

package/src/internal/arbitrary/runner.ts

@@ -3,7 +3,9 @@ import type {
   ArrayOptions,
   CheckOptions,
   CheckResult,
+  Exhausted,
   GlobalOptions,
+  Passed,
   PropertyError,
   PropertyFailure,
   Replay,
@@ -13,12 +15,16 @@ import type {
   SchemaOptions
 } from "../../Arbitrary.ts"
 import * as Effect from "../../Effect.ts"
+import * as Fiber from "../../Fiber.ts"
 import * as Option from "../../Option.ts"
 import { pipeArguments } from "../../Pipeable.ts"
+import * as Queue from "../../Queue.ts"
 import * as Random from "../../Random.ts"
 import type * as Result from "../../Result.ts"
 import * as Scheduler from "../../Scheduler.ts"
 import type * as Schema from "../../Schema.ts"
+import * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import { done } from "../core.ts"
 import * as InternalRecord from "../record.ts"
 import * as Arrays from "./array.ts"
@@ -582,6 +588,111 @@ const followReplay = Effect.fnUntraced(function*<A, E, R>(
   return { _tag: "Replayed", current, failure } as const
 })
 
+interface SearchOptions {
+  readonly runs: number
+  readonly size: number
+  readonly maxDiscards: number
+  readonly seed: string | number
+  readonly maxOpsBeforeYield: number
+}
+
+interface SearchCase<A> {
+  readonly sample: Model.Sample<A>
+  readonly attempt: number
+  readonly size: number
+  readonly runs: number
+  readonly discards: number
+}
+
+interface Found<A, E> extends SearchCase<A> {
+  readonly _tag: "Found"
+  readonly failure: PropertyFailure<E>
+}
+
+type SearchResult<A, E> = Passed | Exhausted | Found<A, E>
+
+// Only the search advances this cursor. Each generated case advances size, while discards retain it.
+// This gives both search strategies the sequential seed and size schedule, independently of evaluation timing.
+const makeSearch = <A>(self: Arbitrary<A>, options: SearchOptions) => {
+  const seed = hashSeed(options.seed)
+  let runs = 0
+  let discards = 0
+  let attemptIndex = 0
+  return Effect.gen(function*(): Effect.fn.Return<SearchCase<A> | Exhausted> {
+    const size = options.runs === 1 ? options.size : Math.round(runs * options.size / (options.runs - 1))
+    while (true) {
+      const index = attemptIndex++
+      const sample = yield* generateAttempt(self.gen, seed, index, size, true)
+      if (sample._tag === "Generated") {
+        return { sample, attempt: index, size, runs: ++runs, discards }
+      }
+      if (++discards > options.maxDiscards) return { _tag: "Exhausted", runs, discards, seed: options.seed }
+      if (options.maxOpsBeforeYield <= 1 || discards % options.maxOpsBeforeYield === 0) yield* Effect.yieldNow
+    }
+  })
+}
+
+const searchSequential = Effect.fnUntraced(function*<A, E, R>(
+  next: Effect.Effect<SearchCase<A> | Exhausted>,
+  property: (value: A) => boolean | Effect.Effect<boolean, E, R>,
+  runs: number
+): Effect.fn.Return<SearchResult<A, E>, never, R> {
+  while (true) {
+    const current = yield* next
+    if ("_tag" in current) return current
+    const outcome = yield* evaluateProperty(property, current.sample.value)
+    if (outcome._tag !== "Passed") return { ...current, _tag: "Found", failure: outcome }
+    if (current.runs === runs) return { _tag: "Passed", runs, discards: current.discards }
+  }
+})
+
+const searchConcurrent = Effect.fnUntraced(function*<A, E, R>(
+  next: Effect.Effect<SearchCase<A> | Exhausted>,
+  property: (value: A) => boolean | Effect.Effect<boolean, E, R>,
+  runs: number,
+  concurrency: number
+): Effect.fn.Return<SearchResult<A, E>, never, R> {
+  interface Pending extends SearchCase<A> {
+    readonly fiber: Fiber.Fiber<typeof passedProperty | PropertyFailure<E>>
+  }
+  const queue = yield* Queue.make<Pending | Exhausted>()
+  const window = yield* Semaphore.make(concurrency)
+  const scope = yield* Scope.make("parallel")
+  const produce = Effect.gen(function*() {
+    for (let index = 0; index < runs; index++) {
+      // Hold each permit until its result is consumed, bounding both work and buffered results.
+      yield* window.take(1)
+      const current = yield* next
+      if ("_tag" in current) {
+        yield* Queue.offer(queue, current)
+        return
+      }
+      const fiber = yield* Effect.forkIn(Effect.suspend(() => evaluateProperty(property, current.sample.value)), scope)
+      yield* Queue.offer(queue, { ...current, fiber })
+    }
+  }).pipe(
+    // Queue failure follows already queued cases, so speculative generation defects cannot overtake them.
+    Effect.catchCause((cause) => Queue.failCause(queue, cause)),
+    Effect.awaitAllChildren
+  )
+  return yield* Effect.acquireUseRelease(
+    Effect.forkIn(produce, scope),
+    () =>
+      Effect.gen(function*(): Effect.fn.Return<SearchResult<A, E>, never, R> {
+        while (true) {
+          const current = yield* Queue.take(queue)
+          if ("_tag" in current) return current
+          const outcome = yield* Fiber.join(current.fiber)
+          if (outcome._tag !== "Passed") return { ...current, _tag: "Found", failure: outcome }
+          if (current.runs === runs) return { _tag: "Passed", runs, discards: current.discards }
+          yield* window.release(1)
+        }
+      }),
+    // Generator and evaluation finalizers can depend on each other, so interrupt them independently before awaiting.
+    (_, exit) => Scope.close(scope, exit)
+  )
+})
+
 /** @internal */
 export const checkEffect = Effect.fnUntraced(function*<A, E, R>(
   self: Arbitrary<A>,
@@ -612,6 +723,7 @@ export const checkEffect = Effect.fnUntraced(function*<A, E, R>(
 
   const defaults = globalOptions.check
   const runsTarget = positive(options?.runs ?? defaults?.runs, 100, "runs")
+  const concurrency = positive(options?.concurrency ?? defaults?.concurrency, 1, "concurrency")
   const size = natural(options?.size ?? defaults?.size, 10, "size")
   const maxDiscards = natural(
     options?.maxDiscards ?? defaults?.maxDiscards,
@@ -622,41 +734,26 @@ export const checkEffect = Effect.fnUntraced(function*<A, E, R>(
   const seedOption = options?.seed ?? defaults?.seed
   const maxOpsBeforeYield = yield* Scheduler.MaxOpsBeforeYield
   const seed = yield* resolveMasterSeed(seedOption)
-  const seedState = hashSeed(seed)
-  let runs = 0
-  let discards = 0
-  let attemptIndex = 0
-  while (runs < runsTarget) {
-    const currentAttempt = attemptIndex++
-    const currentSize = runsTarget === 1 ? size : Math.round(runs * size / (runsTarget - 1))
-    const attempt = yield* generateAttempt(self.gen, seedState, currentAttempt, currentSize, true)
-    if (attempt._tag === "Discarded") {
-      if (++discards > maxDiscards) return { _tag: "Exhausted", runs, discards, seed }
-      if (maxOpsBeforeYield <= 1 || discards % maxOpsBeforeYield === 0) yield* Effect.yieldNow
-      continue
-    }
-    const outcome = yield* evaluateProperty(property, attempt.value)
-    if (outcome._tag === "Passed") {
-      runs++
-      continue
-    }
-    const minimized = yield* shrink(attempt, outcome, property, maxShrinks)
-    return {
-      _tag: "Falsified",
-      initialInput: attempt.value,
-      shrunkInput: minimized.current.value,
-      failure: minimized.failure,
-      runs: runs + 1,
-      discards,
-      shrinks: minimized.shrinks,
-      replay: makeReplay({
-        seed,
-        attempt: currentAttempt,
-        size: currentSize,
-        path: minimized.path,
-        failureTag: outcome._tag
-      })
-    }
+  const next = makeSearch(self, { runs: runsTarget, size, maxDiscards, seed, maxOpsBeforeYield })
+  const result = yield* concurrency === 1
+    ? searchSequential(next, property, runsTarget)
+    : searchConcurrent(next, property, runsTarget, concurrency)
+  if (result._tag !== "Found") return result
+  const minimized = yield* shrink(result.sample, result.failure, property, maxShrinks)
+  return {
+    _tag: "Falsified",
+    initialInput: result.sample.value,
+    shrunkInput: minimized.current.value,
+    failure: minimized.failure,
+    runs: result.runs,
+    discards: result.discards,
+    shrinks: minimized.shrinks,
+    replay: makeReplay({
+      seed,
+      attempt: result.attempt,
+      size: result.size,
+      path: minimized.path,
+      failureTag: result.failure._tag
+    })
   }
-  return { _tag: "Passed", runs, discards }
 })

package/src/internal/core.ts

@@ -216,6 +216,8 @@ export abstract class ReasonBase<Tag extends string> implements Cause.Cause.Reas
       if (options?.overwrite !== true && newAnnotations.has(key)) return
       newAnnotations.set(key, value)
     })
+    // Keep the reason when nothing was added, so interrupts still match by identity.
+    if (options?.overwrite !== true && newAnnotations.size === this.annotations.size) return this
     const self = Object.assign(Object.create(Object.getPrototypeOf(this)), this)
     self.annotations = newAnnotations
     return self

package/src/internal/effect.ts

@@ -1005,7 +1005,10 @@ export const fail: <E>(error: E) => Effect.Effect<never, E> = exitFail
 export const sync: <A>(thunk: LazyArg<A>) => Effect.Effect<A> = makePrimitive({
   op: "Sync",
   [evaluate](fiber): Primitive | Yield {
-    const value = this[args]()
+    // call the thunk without a receiver, so V8 does not name its frame after
+    // the args property, which the stack cleaner cuts at
+    const thunk = this[args]
+    const value = thunk()
     const cont = fiber.getCont(contA)
     return cont ? cont[contA](value, fiber) : fiber.yieldWith(exitSucceed(value))
   }
@@ -1017,7 +1020,9 @@ export const suspend: <A, E, R>(
 ) => Effect.Effect<A, E, R> = makePrimitive({
   op: "Suspend",
   [evaluate](_fiber) {
-    return this[args]()
+    // see Sync
+    const thunk = this[args]
+    return thunk()
   }
 })
 
@@ -1353,6 +1358,17 @@ const makeFn = (
     : (pipeables.shift()!).bind(bodyOrOptions.self)
   const definitionName = `${name} (definition)`
   const definitionStack = defError ? fnStackCleaner(() => defError.stack) : constUndefined
+  // Built outside the traced function so the frame cannot capture its `arguments`,
+  // which forked fibers inheriting the frame would otherwise keep alive.
+  const makeCallFrame = (callError: Error | undefined) => (prev: StackFrame | undefined): StackFrame => ({
+    name,
+    stack: callError ? fnStackCleaner(() => callError.stack) : constUndefined,
+    parent: {
+      name: definitionName,
+      stack: definitionStack,
+      parent: prev
+    }
+  })
 
   return defineFunctionLength(body.length, function(this: any, ...args: Array<any>) {
     let result = suspend(() => {
@@ -1377,15 +1393,7 @@ const makeFn = (
         useSpan(name, spanOptions!, (span) => provideParentSpan(result, span)) :
         result,
       CurrentStackFrame,
-      (prev) => ({
-        name,
-        stack: callError ? fnStackCleaner(() => callError.stack) : constUndefined,
-        parent: {
-          name: definitionName,
-          stack: definitionStack,
-          parent: prev
-        }
-      })
+      makeCallFrame(callError)
     )
   })
 }
@@ -2057,17 +2065,17 @@ export const exitFindDefect = Filter.composePassthrough(
 /** @internal */
 export const exitHasInterrupts = <A, E>(
   self: Exit.Exit<A, E>
-): self is Exit.Failure<A, E> => self._tag === "Failure" && hasInterrupts(self.cause)
+): boolean => self._tag === "Failure" && hasInterrupts(self.cause)
 
 /** @internal */
 export const exitHasDies = <A, E>(
   self: Exit.Exit<A, E>
-): self is Exit.Failure<A, E> => self._tag === "Failure" && hasDies(self.cause)
+): boolean => self._tag === "Failure" && hasDies(self.cause)
 
 /** @internal */
 export const exitHasFails = <A, E>(
   self: Exit.Exit<A, E>
-): self is Exit.Failure<A, E> => self._tag === "Failure" && hasFails(self.cause)
+): boolean => self._tag === "Failure" && hasFails(self.cause)
 
 /** @internal */
 export const exitVoid: Exit.Exit<void> = exitSucceed(void 0)
@@ -6307,7 +6315,7 @@ export const annotateCurrentSpan: {
 } = (...args: [Record<string, unknown>] | [key: string, value: unknown]) =>
   withFiber((fiber) => {
     const span = fiber.currentSpanLocal
-    if (span) {
+    if (span && span.status._tag !== "Ended") {
       if (args.length === 1) {
         for (const [key, value] of Object.entries(args[0])) {
           span.attribute(key, value)
@@ -6950,7 +6958,7 @@ export const tracerLogger = loggerMake<unknown, void>(({ cause, fiber, logLevel,
   const clock = fiber.getRef(ClockRef)
   const annotations = fiber.getRef(CurrentLogAnnotations)
   const span = fiber.cache.span
-  if (span === undefined || span._tag === "ExternalSpan") return
+  if (span === undefined || span._tag === "ExternalSpan" || span.status._tag === "Ended") return
   const attributes: Record<string, unknown> = {}
   for (const [key, value] of Object.entries(annotations)) {
     InternalRecord.assignProperty(attributes, key, value)

package/src/internal/equal.ts

@@ -29,3 +29,20 @@ export const byReferenceInstances = new WeakSet<object>()
 
 /** @internal */
 export const viewBytes = (view: DataView): Uint8Array => new Uint8Array(view.buffer, view.byteOffset, view.byteLength)
+
+/** @internal */
+export const isArrayBufferLike = (u: unknown): u is ArrayBufferLike =>
+  u instanceof ArrayBuffer || (typeof SharedArrayBuffer !== "undefined" && u instanceof SharedArrayBuffer)
+
+/**
+ * Returns `undefined` for detached buffers, which can no longer be read.
+ *
+ * @internal
+ */
+export const bufferBytes = (buffer: ArrayBufferLike): Uint8Array | undefined => {
+  try {
+    return new Uint8Array(buffer)
+  } catch {
+    return undefined
+  }
+}

package/src/internal/jsonSchema.ts

@@ -0,0 +1,27 @@
+/** @internal */
+export function getSubschemaKind(keyword: string): "schema" | "map" | "array" | undefined {
+  switch (keyword) {
+    case "$defs":
+    case "properties":
+    case "patternProperties":
+    case "dependentSchemas":
+      return "map"
+    case "allOf":
+    case "anyOf":
+    case "oneOf":
+    case "prefixItems":
+      return "array"
+    case "not":
+    case "additionalProperties":
+    case "propertyNames":
+    case "unevaluatedProperties":
+    case "items":
+    case "contains":
+    case "unevaluatedItems":
+    case "if":
+    case "then":
+    case "else":
+    case "contentSchema":
+      return "schema"
+  }
+}

package/src/internal/matcher.ts

@@ -140,7 +140,7 @@ const makePredicate = (pattern: unknown): Predicate.Predicate<unknown> => {
     const len = predicates.length
 
     return (u: unknown) => {
-      if (!Array.isArray(u)) {
+      if (!Array.isArray(u) || u.length < len) {
         return false
       }
 

package/src/internal/schema/compilerRegistry.ts

@@ -58,6 +58,7 @@ export interface Entry {
   readonly is?: Is | undefined
   readonly decode?: Decode | undefined
   readonly make?: Make | undefined
+  readonly compiledMakeEffect?: Parser | undefined
   readonly decodeEffect: Parser
   readonly parser: Parser
   readonly makeEffect: Parser
@@ -117,6 +118,10 @@ class CompilerEntry extends InterpretedEntry {
     return this.save("make", this.operation("make"))
   }
 
+  get compiledMakeEffect(): Parser | undefined {
+    return this.save("compiledMakeEffect", this.operation("makeEffect"))
+  }
+
   override get decodeEffect(): Parser {
     return this.save(
       "decodeEffect",
@@ -132,7 +137,7 @@ class CompilerEntry extends InterpretedEntry {
   }
 
   override get makeEffect(): Parser {
-    const makeEffect = this.operation("makeEffect")
+    const makeEffect = this.compiledMakeEffect
     if (makeEffect !== undefined) return this.save("makeEffect", makeEffect)
     const child = (ast: SchemaAST.AST): Parser => lazyParser(this.resolve, ast, "makeEffect")
     return this.save(

package/src/internal/schema/content.ts

@@ -0,0 +1,18 @@
+const ContentTypeId = Symbol.for("~effect/Schema/content")
+
+/** @internal */
+export interface Content {
+  readonly mediaType: string
+  readonly preserveSchema: boolean
+}
+
+/** @internal */
+export function setContent<A extends object>(operation: A, content: Content): A {
+  Object.defineProperty(operation, ContentTypeId, { value: content })
+  return operation
+}
+
+/** @internal */
+export function getContent(operation: object): Content | undefined {
+  return (operation as { readonly [ContentTypeId]?: Content })[ContentTypeId]
+}