effect 4.0.0-rc.118 → 4.0.0

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/cluster/ClusterWorkflowEngine.ts

@@ -299,7 +299,14 @@ export const make = Effect.gen(function*() {
     )
 
     if (Option.isNone(maybeSuspended)) return
-    yield* sharding.reset(Snowflake.Snowflake(maybeSuspended.value.requestId))
+    if (
+      !(yield* sharding.reset(
+        Snowflake.Snowflake(maybeSuspended.value.requestId),
+        { expectedReplyId: Snowflake.Snowflake(maybeSuspended.value.id) }
+      ))
+    ) {
+      return yield* Effect.fail(new Error("Failed to reset workflow run"))
+    }
     yield* sharding.pollStorage
   })
 

package/src/cluster/MessageStorage.ts

@@ -74,9 +74,16 @@ export class MessageStorage extends Context.Service<MessageStorage, {
   ) => Effect.Effect<void, PersistenceError | MalformedMessage>
 
   /**
-   * Clear the `Reply`s for the given request id.
+   * Clear replies for the given request id. When options.expectedReplyId is
+   * provided, clear only if it is still the latest reply at the storage boundary.
+   * Without it, clear unconditionally.
+   * Custom storage implementations must honor this condition to protect
+   * workflows from stale concurrent resumes.
    */
-  readonly clearReplies: (requestId: Snowflake.Snowflake) => Effect.Effect<void, PersistenceError>
+  readonly clearReplies: (
+    requestId: Snowflake.Snowflake,
+    options?: { readonly expectedReplyId?: Snowflake.Snowflake | undefined }
+  ) => Effect.Effect<void, PersistenceError>
 
   /**
    * Retrieves the replies for the specified requests.
@@ -350,9 +357,16 @@ export type Encoded = {
   readonly saveReply: (reply: Reply.Encoded) => Effect.Effect<void, PersistenceError>
 
   /**
-   * Remove the replies for the specified request.
+   * Remove the replies for the specified request. If options.expectedReplyId
+   * is provided, compare it with the latest reply atomically before clearing.
+   * Without it, clear unconditionally.
+   * Custom storage implementations must honor this condition to protect
+   * workflows from stale concurrent resumes.
    */
-  readonly clearReplies: (requestId: Snowflake.Snowflake) => Effect.Effect<void, PersistenceError>
+  readonly clearReplies: (
+    requestId: Snowflake.Snowflake,
+    options?: { readonly expectedReplyId?: Snowflake.Snowflake | undefined }
+  ) => Effect.Effect<void, PersistenceError>
 
   /**
    * Retrieves the request id for the specified primary key.
@@ -1054,10 +1068,13 @@ export class MemoryDriver extends Context.Service<MemoryDriver>()("effect/cluste
           replyIds.add(reply.id)
           replyLatch.openUnsafe()
         }),
-      clearReplies: (id) =>
+      clearReplies: (id, options) =>
         Effect.sync(() => {
           const entry = requests.get(String(id))
           if (!entry) return
+          if (
+            options?.expectedReplyId !== undefined && entry.replies.at(-1)?.id !== String(options.expectedReplyId)
+          ) return
           entry.replies = []
           entry.lastReceivedChunk = undefined
           unprocessed.add(entry.envelope)

package/src/cluster/Sharding.ts

@@ -195,9 +195,13 @@ export class Sharding extends Context.Service<Sharding, {
   >
 
   /**
-   * Reset the state of a message
+   * Reset the state of a message. When options.expectedReplyId is provided,
+   * reset only if it is still the latest reply. Otherwise reset unconditionally.
    */
-  readonly reset: (requestId: Snowflake.Snowflake) => Effect.Effect<boolean>
+  readonly reset: (
+    requestId: Snowflake.Snowflake,
+    options?: { readonly expectedReplyId?: Snowflake.Snowflake | undefined }
+  ) => Effect.Effect<boolean>
 
   /**
    * Trigger a storage read, which will read all unprocessed messages.
@@ -1208,8 +1212,8 @@ const make = Effect.gen(function*() {
     )
   }
 
-  const reset: Sharding["Service"]["reset"] = (requestId) =>
-    Effect.matchCause(storage.clearReplies(requestId), {
+  const reset: Sharding["Service"]["reset"] = (requestId, options) =>
+    Effect.matchCause(storage.clearReplies(requestId, options), {
       onSuccess: () => true,
       onFailure: () => false
     })

package/src/cluster/SqlMessageStorage.ts

@@ -576,14 +576,25 @@ export const makeEncoded: (options?: {
       ),
 
     clearReplies: Effect.fnUntraced(
-      function*(requestId) {
-        yield* sql`DELETE FROM ${repliesTableSql} WHERE request_id = ${String(requestId)} AND kind = 0`
-        yield* sql`DELETE FROM ${messagesTableSql} WHERE request_id = ${
-          String(requestId)
-        } AND kind = ${messageKindInterrupt}`
-        yield* sql`UPDATE ${messagesTableSql} SET processed = ${sqlFalse}, last_reply_id = NULL, last_read = NULL WHERE request_id = ${
-          String(requestId)
-        }`
+      function*(requestId, options) {
+        const expectedReplyId = options?.expectedReplyId
+        if (expectedReplyId === undefined) {
+          yield* sql`DELETE FROM ${repliesTableSql} WHERE request_id = ${String(requestId)} AND kind = 0`
+          yield* sql`DELETE FROM ${messagesTableSql} WHERE request_id = ${
+            String(requestId)
+          } AND kind = ${messageKindInterrupt}`
+          yield* sql`UPDATE ${messagesTableSql} SET processed = ${sqlFalse}, last_reply_id = NULL, last_read = NULL WHERE request_id = ${
+            String(requestId)
+          }`
+          return
+        }
+        const id = String(requestId)
+        const expected = String(expectedReplyId)
+        // Check at the storage boundary, not at the earlier workflow read.
+        yield* sql`DELETE FROM ${repliesTableSql} WHERE request_id = ${id} AND kind = 0
+          AND EXISTS (SELECT 1 FROM ${messagesTableSql} WHERE id = ${id} AND last_reply_id = ${expected})`
+        yield* sql`UPDATE ${messagesTableSql} SET processed = ${sqlFalse}, last_reply_id = NULL, last_read = NULL
+          WHERE request_id = ${id} AND last_reply_id = ${expected}`
       },
       sql.withTransaction,
       PersistenceError.refail,

package/src/http/HttpEffect.ts

@@ -32,6 +32,7 @@ import * as preResponseHandler from "./internal/preResponseHandler.ts"
 
 /**
  * Runs an HTTP server effect, sends the produced response with the supplied handler, and converts failures into HTTP responses.
+ * On handler failure, the request scope closes with the original cause.
  *
  * @stability unstable
  * @category combinators
@@ -45,8 +46,10 @@ export const toHandled = <E, R, EH, RH>(
   ) => Effect.Effect<unknown, EH, RH>,
   middleware?: HttpMiddleware | undefined
 ): Effect.Effect<void, never, Exclude<R | RH | HttpServerRequest, Scope.Scope>> => {
-  const handleCause = (request: HttpServerRequest, cause: Cause.Cause<E | EH | HttpServerError>) =>
-    Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
+  const handleCause = (frame: RequestFrame, cause: Cause.Cause<E | EH | HttpServerError>) => {
+    frame.cause = cause
+    const request = frame.request
+    return Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
       reportCauseUnsafe(fiber, cause)
       const handler = preResponseHandler.requestPreResponseHandlers.get(request.source)
@@ -67,6 +70,7 @@ export const toHandled = <E, R, EH, RH>(
         () => cont
       )
     })
+  }
 
   // Writes the response, applying any registered pre-response handler first.
   // Returns an `Exit` when the write completes synchronously.
@@ -85,14 +89,15 @@ export const toHandled = <E, R, EH, RH>(
     })
   }
 
-  const withMiddleware = (request: HttpServerRequest): Effect.Effect<
+  const withMiddleware = (frame: RequestFrame): Effect.Effect<
     unknown,
     E | EH | HttpServerError,
     HttpServerRequest | R | RH
   > => {
+    const request = frame.request
     const responded = Effect.matchCauseEffect(self, {
       onSuccess: (response) => sendResponse(request, response),
-      onFailure: (cause) => handleCause(request, cause)
+      onFailure: (cause) => handleCause(frame, cause)
     })
     return middleware === undefined ?
       responded :
@@ -116,9 +121,9 @@ export const toHandled = <E, R, EH, RH>(
   }
 
   // Apply tracing lazily so disabled requests can use the single-frame path.
-  const traced = (request: HttpServerRequest) =>
+  const traced = (frame: RequestFrame) =>
     tracer(
-      withMiddleware(request) as Effect.Effect<
+      withMiddleware(frame) as Effect.Effect<
         HttpServerResponse,
         E | EH | HttpServerError,
         HttpServerRequest | R | RH
@@ -135,13 +140,14 @@ export const toHandled = <E, R, EH, RH>(
     Effect.onExitPrimitive(effect, (exit) => {
       fiber.setContext(frame.prev)
       if (scopeEjected in frame.scope) return undefined
-      return Scope.closeUnsafe(frame.scope, exit)
+      return Scope.closeUnsafe(frame.scope, frame.cause === undefined ? exit : Exit.failCause(frame.cause))
     }, true)
 
   class RequestFrame {
     readonly scope: Scope.Closeable
     readonly prev: Context.Context<never>
     readonly request: HttpServerRequest
+    cause: Cause.Cause<E | EH | HttpServerError> | undefined
     constructor(scope: Scope.Closeable, prev: Context.Context<never>, request: HttpServerRequest) {
       this.scope = scope
       this.prev = prev
@@ -159,7 +165,7 @@ export const toHandled = <E, R, EH, RH>(
       return finishAfter(this, fiber, sent)
     }
     [contE](cause: Cause.Cause<E | EH | HttpServerError>, fiber: Fiber.Fiber<unknown, unknown>) {
-      return finishAfter(this, fiber, handleCause(this.request, cause))
+      return finishAfter(this, fiber, handleCause(this, cause))
     }
   }
 
@@ -177,7 +183,7 @@ export const toHandled = <E, R, EH, RH>(
       ;(fiber as any)._stack.push(frame)
       return self
     }
-    return finishAfter(frame, fiber, middleware === undefined ? traced(frame.request) : withMiddleware(frame.request))
+    return finishAfter(frame, fiber, middleware === undefined ? traced(frame) : withMiddleware(frame))
   }) as any
 }