effect 4.0.6 → 4.1.0

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/index.ts

@@ -164,12 +164,6 @@ export * as Context from "./Context.ts"
  */
 export * as Cron from "./Cron.ts"
 
-/**
- * @stability unstable
- * @since 4.0.0
- */
-export * as Crypto from "./Crypto.ts"
-
 /**
  * @stability stable
  * @since 2.0.0
@@ -290,6 +284,12 @@ export * as Formatter from "./Formatter.ts"
  */
 export * as Function from "./Function.ts"
 
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as Glob from "./Glob.ts"
+
 /**
  * @stability unstable
  * @since 4.0.0

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

@@ -97,7 +97,8 @@ import {
   TracerEnabled,
   TracerSpanAnnotations,
   TracerSpanLinks,
-  TracerTimingEnabled
+  TracerTimingEnabled,
+  UnhandledLogLevel
 } from "./references.ts"
 import { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.ts"
 import { addSpanStackTrace, makeStackCleaner } from "./tracer.ts"
@@ -1005,7 +1006,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 +1021,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()
   }
 })
 
@@ -1284,11 +1290,16 @@ export const gen = <
   return suspend(() => fromIteratorUnsafe(body.call(options.self) as any))
 }
 
+// With `{ self }` the body is `pipeables[0]`, so take it out and bind it.
+const fnBody = (bodyOrOptions: Function | { readonly self: any }, pipeables: Array<Function>): Function =>
+  typeof bodyOrOptions === "function" ? bodyOrOptions : pipeables.shift()!.bind(bodyOrOptions.self)
+
 /** @internal */
 export const fnUntraced: Effect.fn.Untraced = (
-  body: Function,
+  bodyOrOptions: Function | { readonly self: any },
   ...pipeables: Array<any>
 ) => {
+  const body = fnBody(bodyOrOptions, pipeables)
   const fn = pipeables.length === 0
     ? function(this: any) {
       return suspend(() => fromIteratorUnsafe(body.apply(this, arguments)))
@@ -1348,11 +1359,20 @@ const makeFn = (
   addSpan: boolean,
   spanOptions: Tracer.SpanOptionsNoTrace | undefined
 ) => {
-  const body = typeof bodyOrOptions === "function"
-    ? bodyOrOptions
-    : (pipeables.shift()!).bind(bodyOrOptions.self)
+  const body = fnBody(bodyOrOptions, pipeables)
   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,25 +1397,18 @@ 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)
     )
   })
 }
 
 /** @internal */
 export const fnUntracedEager: Effect.fn.Untraced = (
-  body: Function,
+  bodyOrOptions: Function | { readonly self: any },
   ...pipeables: Array<any>
-) =>
-  defineFunctionLength(
+) => {
+  const body = fnBody(bodyOrOptions, pipeables)
+  return defineFunctionLength(
     body.length,
     pipeables.length === 0
       ? function(this: any) {
@@ -1409,6 +1422,7 @@ export const fnUntracedEager: Effect.fn.Untraced = (
         return effect
       }
   )
+}
 
 const fromIteratorEagerUnsafe = (
   evaluate: () => Iterator<Effect.Effect<any, any, any>>
@@ -2057,17 +2071,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)
@@ -3482,19 +3496,29 @@ export const firstSuccessOf = <Eff extends Effect.Effect<any, any, any>>(
 export const eventually = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, never, R> =>
   catch_(self, (_) => flatMap(yieldNow, () => eventually(self)))
 
+/** @internal */
+export const ignoreCauseLogger = (log: true | LogLevel.Severity | "Unhandled") =>
+  log === "Unhandled"
+    ? (...message: ReadonlyArray<any>): Effect.Effect<void> =>
+      withFiber((fiber) => {
+        const level = fiber.getRef(UnhandledLogLevel)
+        return level === undefined ? void_ : logWithLevel(level)(...message)
+      })
+    : logWithLevel(log === true ? undefined : log)
+
 /** @internal */
 export const ignore: <
   Arg extends Effect.Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly log?: boolean | LogLevel.Severity | "Unhandled" | undefined
     readonly message?: string | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly log?: boolean | LogLevel.Severity | "Unhandled" | undefined
     readonly message?: string | undefined
   }
 >(
   effectOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly log?: boolean | LogLevel.Severity | "Unhandled" | undefined
     readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<void, never, _R>
@@ -3503,14 +3527,14 @@ export const ignore: <
     <A, E, R>(
       self: Effect.Effect<A, E, R>,
       options?: {
-        readonly log?: boolean | LogLevel.Severity | undefined
+        readonly log?: boolean | LogLevel.Severity | "Unhandled" | undefined
         readonly message?: string | undefined
       } | undefined
     ): Effect.Effect<void, never, R> => {
       if (!options?.log) {
         return matchEffect(self, { onFailure: (_) => void_, onSuccess: (_) => void_ })
       }
-      const logEffect = logWithLevel(options.log === true ? undefined : options.log)
+      const logEffect = ignoreCauseLogger(options.log)
       return matchCauseEffect(self, {
         onFailure(cause) {
           const error = findRecoverableError(cause)
@@ -3528,16 +3552,16 @@ export const ignore: <
 /** @internal */
 export const ignoreCause: <
   Arg extends Effect.Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly log?: boolean | LogLevel.Severity | "Unhandled" | undefined
     readonly message?: string | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly log?: boolean | LogLevel.Severity | "Unhandled" | undefined
     readonly message?: string | undefined
   }
 >(
   effectOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly log?: boolean | LogLevel.Severity | "Unhandled" | undefined
     readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<void, never, _R>
@@ -3546,14 +3570,14 @@ export const ignoreCause: <
     <A, E, R>(
       self: Effect.Effect<A, E, R>,
       options?: {
-        readonly log?: boolean | LogLevel.Severity | undefined
+        readonly log?: boolean | LogLevel.Severity | "Unhandled" | undefined
         readonly message?: string | undefined
       } | undefined
     ): Effect.Effect<void, never, R> => {
       if (!options?.log) {
         return matchCauseEffect(self, { onFailure: (_) => void_, onSuccess: (_) => void_ })
       }
-      const logEffect = logWithLevel(options.log === true ? undefined : options.log)
+      const logEffect = ignoreCauseLogger(options.log)
       return matchCauseEffect(self, {
         onFailure: (cause) => options.message === undefined ? logEffect(cause) : logEffect(options.message, cause),
         onSuccess: (_) => void_
@@ -6307,7 +6331,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 +6974,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
+  }
+}