effect 4.0.0-beta.20 → 4.0.0-beta.22

package/src/Trie.ts

@@ -16,11 +16,11 @@
  * @since 2.0.0
  */
 import type { Equal } from "./Equal.ts"
-import type * as Filter from "./Filter.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import * as TR from "./internal/trie.ts"
 import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import type { Result } from "./Result.ts"
 import type { Covariant, NoInfer } from "./Types.ts"
 
 const TypeId = TR.TrieTypeId
@@ -1585,7 +1585,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, B, X>(f: Filter.Filter<A, B, X, [key: string]>): (self: Trie<A>) => Trie<B>
+  <A, B, X>(f: (input: A, key: string) => Result<B, X>): (self: Trie<A>) => Trie<B>
   /**
    * Maps over the entries of the `Trie` using the specified filter and keeps
    * only successful results.
@@ -1634,7 +1634,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, B, X>(self: Trie<A>, f: Filter.Filter<A, B, X, [key: string]>): Trie<B>
+  <A, B, X>(self: Trie<A>, f: (input: A, key: string) => Result<B, X>): Trie<B>
 } = TR.filterMap
 
 /**

package/src/TxHashMap.ts

@@ -3,7 +3,6 @@
  */
 
 import * as Effect from "./Effect.ts"
-import type * as Filter from "./Filter.ts"
 import { format } from "./Formatter.ts"
 import { dual } from "./Function.ts"
 import * as HashMap from "./HashMap.ts"
@@ -12,6 +11,7 @@ import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import type { Result } from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
 
 const TypeId = "~effect/transactions/TxHashMap"
@@ -2835,7 +2835,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <V, K, A, X>(f: Filter.Filter<V, A, X, [key: K]>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  <V, K, A, X>(f: (input: V, key: K) => Result<A, X>): (self: TxHashMap<K, V>) => Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
   /**
    * Combines filtering and mapping in a single operation. Applies a filter to each
    * entry, keeping only successful results and transforming them.
@@ -2893,12 +2893,12 @@ export const filterMap: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, V, A, X>(self: TxHashMap<K, V>, f: Filter.Filter<V, A, X, [key: K]>): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
+  <K, V, A, X>(self: TxHashMap<K, V>, f: (input: V, key: K) => Result<A, X>): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction>
 } = dual(
   2,
   <K, V, A, X>(
     self: TxHashMap<K, V>,
-    f: Filter.Filter<V, A, X, [key: K]>
+    f: (input: V, key: K) => Result<A, X>
   ): Effect.Effect<TxHashMap<K, A>, never, Effect.Transaction> =>
     Effect.gen(function*() {
       const currentMap = yield* TxRef.get(self.ref)

package/src/TxPubSub.ts

@@ -430,7 +430,7 @@ export const publish: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(value: A): (self: TxPubSub<A>) => Effect.Effect<boolean>
+  <A>(value: A): (self: TxPubSub<A>) => Effect.Effect<boolean, never, Effect.Transaction>
   // =============================================================================
   // Mutations
   // =============================================================================
@@ -470,7 +470,7 @@ export const publish: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxPubSub<A>, value: A): Effect.Effect<boolean>
+  <A>(self: TxPubSub<A>, value: A): Effect.Effect<boolean, never, Effect.Transaction>
 } = dual(
   2,
   <A>(self: TxPubSub<A>, value: A): Effect.Effect<boolean, never, Effect.Transaction> =>
@@ -546,7 +546,7 @@ export const publishAll: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(values: Iterable<A>): (self: TxPubSub<A>) => Effect.Effect<boolean>
+  <A>(values: Iterable<A>): (self: TxPubSub<A>) => Effect.Effect<boolean, never, Effect.Transaction>
   /**
    * Publishes all messages from an iterable to all current subscribers.
    *
@@ -575,7 +575,7 @@ export const publishAll: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxPubSub<A>, values: Iterable<A>): Effect.Effect<boolean>
+  <A>(self: TxPubSub<A>, values: Iterable<A>): Effect.Effect<boolean, never, Effect.Transaction>
 } = dual(
   2,
   <A>(self: TxPubSub<A>, values: Iterable<A>): Effect.Effect<boolean, never, Effect.Transaction> =>

package/src/internal/effect.ts

@@ -493,40 +493,6 @@ const fiberIdStore = { id: 0 }
 /** @internal */
 export const getCurrentFiber = (): Fiber.Fiber<any, any> | undefined => (globalThis as any)[currentFiberTypeId]
 
-const keepAlive = (() => {
-  let isAvailable: boolean | undefined
-  const start = () => {
-    if (isAvailable === true) return setInterval(constVoid, 2_147_483_647)
-    else if (isAvailable === false) return undefined
-
-    try {
-      const running = setInterval(constVoid, 2_147_483_647)
-      isAvailable = true
-      return running
-    } catch {
-      isAvailable = false
-      return undefined
-    }
-  }
-  let count = 0
-  let running: ReturnType<typeof globalThis.setInterval> | undefined = undefined
-  return ({
-    increment() {
-      count++
-      if (running === undefined) {
-        running = start()
-      }
-    },
-    decrement() {
-      count--
-      if (count === 0 && running !== undefined) {
-        clearInterval(running)
-        running = undefined
-      }
-    }
-  })
-})()
-
 /** @internal */
 export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   constructor(
@@ -1056,10 +1022,8 @@ const callbackOptions: <A, E = never, R = never>(
     }, controller?.signal)
     if (yielded !== false) return yielded
     yielded = true
-    keepAlive.increment()
     fiber._yielded = () => {
       resumed = true
-      keepAlive.decrement()
     }
     if (controller === undefined && onCancel === undefined) {
       return Yield
@@ -1133,7 +1097,7 @@ export const fnUntraced: Effect.fn.Untraced = (
   body: Function,
   ...pipeables: Array<any>
 ) => {
-  return pipeables.length === 0
+  const fn = pipeables.length === 0
     ? function(this: any) {
       return suspend(() => fromIteratorUnsafe(body.apply(this, arguments)))
     }
@@ -1144,8 +1108,15 @@ export const fnUntraced: Effect.fn.Untraced = (
       }
       return effect
     }
+  return defineFunctionLength(body.length, fn)
 }
 
+const defineFunctionLength = <F extends Function>(length: number, fn: F): F =>
+  Object.defineProperty(fn, "length", {
+    value: length,
+    configurable: true
+  })
+
 const fnStackCleaner = makeStackCleaner(2)
 
 /** @internal */
@@ -1186,7 +1157,7 @@ const makeFn = (
     ? bodyOrOptions
     : (pipeables.pop()!).bind(bodyOrOptions.self)
 
-  return function(this: any, ...args: Array<any>) {
+  return defineFunctionLength(body.length, function(this: any, ...args: Array<any>) {
     let result = suspend(() => {
       const iter = body.apply(this, arguments)
       return isEffect(iter) ? iter : fromIteratorUnsafe(iter)
@@ -1216,7 +1187,7 @@ const makeFn = (
         }
       })
     )
-  }
+  })
 }
 
 /** @internal */
@@ -1224,17 +1195,20 @@ export const fnUntracedEager: Effect.fn.Untraced = (
   body: Function,
   ...pipeables: Array<any>
 ) =>
-  pipeables.length === 0
-    ? function(this: any) {
-      return fromIteratorEagerUnsafe(() => body.apply(this, arguments))
-    }
-    : function(this: any) {
-      let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments))
-      for (const pipeable of pipeables) {
-        effect = pipeable(effect)
+  defineFunctionLength(
+    body.length,
+    pipeables.length === 0
+      ? function(this: any) {
+        return fromIteratorEagerUnsafe(() => body.apply(this, arguments))
       }
-      return effect
-    }
+      : function(this: any) {
+        let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments))
+        for (const pipeable of pipeables) {
+          effect = pipeable(effect)
+        }
+        return effect
+      }
+  )
 
 const fromIteratorEagerUnsafe = (
   evaluate: () => Iterator<Effect.Yieldable<any, any, any, any>>
@@ -4289,6 +4263,90 @@ export const validate: {
     )
 )
 
+/** @internal */
+export const findFirst: {
+  <A, E, R>(
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): (elements: Iterable<A>) => Effect.Effect<Option.Option<A>, E, R>
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Option.Option<A>, E, R>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Option.Option<A>, E, R> =>
+    suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const next = iterator.next()
+      if (!next.done) {
+        return findFirstLoop(iterator, 0, predicate, next.value)
+      }
+      return succeed(Option.none())
+    })
+)
+
+const findFirstLoop = <A, E, R>(
+  iterator: Iterator<A>,
+  index: number,
+  predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>,
+  value: A
+): Effect.Effect<Option.Option<A>, E, R> =>
+  flatMap(predicate(value, index), (keep) => {
+    if (keep) {
+      return succeed(Option.some(value))
+    }
+    const next = iterator.next()
+    if (!next.done) {
+      return findFirstLoop(iterator, index + 1, predicate, next.value)
+    }
+    return succeed(Option.none())
+  })
+
+/** @internal */
+export const findFirstFilter: {
+  <A, B, X, E, R>(
+    filter: (input: NoInfer<A>, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
+  ): (elements: Iterable<A>) => Effect.Effect<Option.Option<B>, E, R>
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: (input: NoInfer<A>, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
+  ): Effect.Effect<Option.Option<B>, E, R>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: (input: A, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
+  ): Effect.Effect<Option.Option<B>, E, R> =>
+    suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const next = iterator.next()
+      if (!next.done) {
+        return findFirstFilterLoop(iterator, 0, filter, next.value)
+      }
+      return succeed(Option.none())
+    })
+)
+
+const findFirstFilterLoop = <A, B, X, E, R>(
+  iterator: Iterator<A>,
+  index: number,
+  filter: (input: A, i: number) => Effect.Effect<Result.Result<B, X>, E, R>,
+  value: A
+): Effect.Effect<Option.Option<B>, E, R> =>
+  flatMap(filter(value, index), (result) => {
+    if (Result.isSuccess(result)) {
+      return succeed(Option.some(result.success))
+    }
+    const next = iterator.next()
+    if (!next.done) {
+      return findFirstFilterLoop(iterator, index + 1, filter, next.value)
+    }
+    return succeed(Option.none())
+  })
+
 /** @internal */
 export const whileLoop: <A, E, R>(options: {
   readonly while: LazyArg<boolean>

package/src/internal/hashMap.ts

@@ -3,7 +3,6 @@
  */
 
 import * as Equal_ from "../Equal.ts"
-import type * as Filter from "../Filter.ts"
 import { format } from "../Formatter.ts"
 import { dual, pipe } from "../Function.ts"
 import * as Hash from "../Hash.ts"
@@ -1257,9 +1256,9 @@ export const compact = <K, A>(self: HashMap<K, Option.Option<A>>): HashMap<K, A>
 
 /** @internal */
 export const filterMap = dual<
-  <A, K, B, X>(f: Filter.Filter<A, B, X, [key: K]>) => (self: HashMap<K, A>) => HashMap<K, B>,
-  <K, A, B, X>(self: HashMap<K, A>, f: Filter.Filter<A, B, X, [key: K]>) => HashMap<K, B>
->(2, <K, A, B, X>(self: HashMap<K, A>, f: Filter.Filter<A, B, X, [key: K]>): HashMap<K, B> => {
+  <A, K, B, X>(f: (input: A, key: K) => Result.Result<B, X>) => (self: HashMap<K, A>) => HashMap<K, B>,
+  <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result.Result<B, X>) => HashMap<K, B>
+>(2, <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result.Result<B, X>): HashMap<K, B> => {
   let result = empty<K, B>()
   for (const [key, value] of self) {
     const mapped = f(value, key)

package/src/internal/trie.ts

@@ -1,5 +1,4 @@
 import * as Equal from "../Equal.ts"
-import type * as Filter from "../Filter.ts"
 import { format } from "../Formatter.ts"
 import { dual, pipe } from "../Function.ts"
 import * as Hash from "../Hash.ts"
@@ -312,10 +311,10 @@ export const filter: {
 /** @internal */
 export const filterMap = dual<
   <A, B, X>(
-    f: Filter.Filter<A, B, X, [key: string]>
+    f: (input: A, key: string) => Result.Result<B, X>
   ) => (self: TR.Trie<A>) => TR.Trie<B>,
-  <A, B, X>(self: TR.Trie<A>, f: Filter.Filter<A, B, X, [key: string]>) => TR.Trie<B>
->(2, <A, B, X>(self: TR.Trie<A>, f: Filter.Filter<A, B, X, [key: string]>): TR.Trie<B> =>
+  <A, B, X>(self: TR.Trie<A>, f: (input: A, key: string) => Result.Result<B, X>) => TR.Trie<B>
+>(2, <A, B, X>(self: TR.Trie<A>, f: (input: A, key: string) => Result.Result<B, X>): TR.Trie<B> =>
   reduce(
     self,
     empty<B>(),

package/src/unstable/ai/Chat.ts

@@ -296,42 +296,8 @@ const encodeHistoryJson = Schema.encodeUnknownEffect(Schema.fromJsonString(Promp
 // Constructors
 // =============================================================================
 
-/**
- * Creates a new Chat service with empty conversation history.
- *
- * This is the most common way to start a fresh chat session without
- * any initial context or system prompts.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- * import { Chat } from "effect/unstable/ai"
- *
- * const freshChat = Effect.gen(function*() {
- *   const chat = yield* Chat.empty
- *
- *   const response = yield* chat.generateText({
- *     prompt: "Hello! Can you introduce yourself?"
- *   })
- *
- *   console.log(response.content)
- *
- *   return chat
- * })
- * ```
- *
- * @since 4.0.0
- * @category constructors
- */
-export const empty: Effect.Effect<Service> = Effect.gen(function*() {
-  const history = yield* Ref.make(Prompt.empty)
-  const services = yield* Effect.services<never>()
-  const semaphore = yield* Semaphore.make(1)
-
-  const provideContext = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.updateServices(effect, (existing) => ServiceMap.merge(services, existing))
-  const provideContextStream = <A, E, R>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
-    Stream.updateServices(stream, (existing) => ServiceMap.merge(services, existing))
+const makeUnsafe = (history: Ref.Ref<Prompt.Prompt>) => {
+  const semaphore = Semaphore.makeUnsafe(1)
 
   return Chat.of({
     history,
@@ -368,7 +334,6 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
 
         return response
       },
-      provideContext,
       semaphore.withPermits(1),
       (effect) => Effect.withSpan(effect, "Chat.generateText", { captureStackTrace: false })
     ),
@@ -397,7 +362,6 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
               semaphore.release(1)
             )
         )).pipe(
-          provideContextStream,
           Stream.withSpan("Chat.streamText", {
             captureStackTrace: false
           })
@@ -418,7 +382,6 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
 
         return response
       },
-      provideContext,
       semaphore.withPermits(1),
       (effect, options) =>
         Effect.withSpan(effect, "Chat.generateObject", {
@@ -429,7 +392,36 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
         })
     )
   })
-})
+}
+
+/**
+ * Creates a new Chat service with empty conversation history.
+ *
+ * This is the most common way to start a fresh chat session without
+ * any initial context or system prompts.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Chat } from "effect/unstable/ai"
+ *
+ * const freshChat = Effect.gen(function*() {
+ *   const chat = yield* Chat.empty
+ *
+ *   const response = yield* chat.generateText({
+ *     prompt: "Hello! Can you introduce yourself?"
+ *   })
+ *
+ *   console.log(response.content)
+ *
+ *   return chat
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const empty: Effect.Effect<Service> = Effect.sync(() => makeUnsafe(Ref.makeUnsafe(Prompt.empty)))
 
 /**
  * Creates a new Chat service from an initial prompt.
@@ -489,13 +481,8 @@ export const empty: Effect.Effect<Service> = Effect.gen(function*() {
  * @since 4.0.0
  * @category constructors
  */
-export const fromPrompt = Effect.fnUntraced(
-  function*(prompt: Prompt.RawInput) {
-    const chat = yield* empty
-    yield* Ref.set(chat.history, Prompt.make(prompt))
-    return chat
-  }
-)
+export const fromPrompt = (prompt: Prompt.RawInput) =>
+  Effect.sync(() => makeUnsafe(Ref.makeUnsafe(Prompt.make(prompt))))
 
 /**
  * Creates a Chat service from previously exported chat data.
@@ -534,8 +521,7 @@ export const fromPrompt = Effect.fnUntraced(
  */
 export const fromExport = (data: unknown): Effect.Effect<
   Service,
-  Schema.SchemaError,
-  LanguageModel.LanguageModel
+  Schema.SchemaError
 > => Effect.flatMap(decodeHistory(data), fromPrompt)
 
 /**
@@ -576,8 +562,7 @@ export const fromExport = (data: unknown): Effect.Effect<
  */
 export const fromJson = (data: string): Effect.Effect<
   Service,
-  Schema.SchemaError,
-  LanguageModel.LanguageModel
+  Schema.SchemaError
 > => Effect.flatMap(decodeHistoryJson(data), fromPrompt)
 
 // =============================================================================

package/src/unstable/ai/LanguageModel.ts

@@ -1236,7 +1236,6 @@ export const make: (params: ConstructorParams) => Effect.Effect<Service> = Effec
     const queue = yield* Queue.make<
       Response.StreamPart<Tools>,
       | AiError.AiError
-      | AiError.AiErrorReason
       | Cause.Done
       | Schema.SchemaError
     >()

package/src/unstable/ai/McpServer.ts

@@ -1057,7 +1057,8 @@ const compileUriTemplate = (segments: TemplateStringsArray, ...schemas: Readonly
       const key = String(i)
       arr.push(toCodecStringTree)
       routerPath += `:${key}${segment.replace(":", "::")}`
-      const paramName = isParam(toCodecStringTree) ? toCodecStringTree.name : `param${key}`
+      const schema = schemas[i]
+      const paramName = isParam(schema) ? (schema as Param<string, Schema.Top>).name : `param${key}`
       params[paramName] = toCodecStringTree
       uriPath += `{${paramName}}${segment}`
     }

package/src/unstable/ai/Tool.ts

@@ -952,7 +952,7 @@ export type HandlerError<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? _Config["failureMode"] extends "error" ? _Config["failure"]["Type"] | AiError.AiError | AiError.AiErrorReason
+> ? _Config["failureMode"] extends "error" ? _Config["failure"]["Type"] | AiError.AiError
   : never
   : never
 

package/src/unstable/http/HttpEffect.ts

@@ -37,7 +37,7 @@ export const toHandled = <E, R, EH, RH>(
       const fiber = Fiber.getCurrent()!
       reportCauseUnsafe(fiber, cause)
       const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-      const handler = requestPreResponseHandlers.get(request)
+      const handler = requestPreResponseHandlers.get(request.source)
       const cont = cause.reasons.length === 0 ? Effect.succeed(response) : Effect.failCause(cause)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
@@ -60,7 +60,7 @@ export const toHandled = <E, R, EH, RH>(
     onSuccess: (response) => {
       const fiber = Fiber.getCurrent()!
       const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-      const handler = requestPreResponseHandlers.get(request)
+      const handler = requestPreResponseHandlers.get(request.source)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
         return Effect.mapEager(handleResponse(request, response), () => response)

package/src/unstable/http/HttpMiddleware.ts

@@ -46,7 +46,7 @@ export declare namespace HttpMiddleware {
  */
 export const make = <M extends HttpMiddleware>(middleware: M): M => middleware
 
-const loggerDisabledRequests = new WeakSet<HttpServerRequest>()
+const loggerDisabledRequests = new WeakSet<object>()
 
 /**
  * @since 4.0.0
@@ -55,7 +55,7 @@ const loggerDisabledRequests = new WeakSet<HttpServerRequest>()
 export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | HttpServerRequest> =>
   Effect.withFiber((fiber) => {
     const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-    loggerDisabledRequests.add(request)
+    loggerDisabledRequests.add(request.source)
     return self
   })
 
@@ -97,7 +97,7 @@ export const logger: <E, R>(
     const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
     return Effect.withLogSpan(
       Effect.flatMap(Effect.exit(httpApp), (exit) => {
-        if (loggerDisabledRequests.has(request)) {
+        if (loggerDisabledRequests.has(request.source)) {
           return exit
         } else if (exit._tag === "Failure") {
           const [response, cause] = causeResponseStripped(exit.cause)

package/src/unstable/http/HttpServerRequest.ts

@@ -43,7 +43,7 @@ export const TypeId = "~effect/http/HttpServerRequest"
  */
 export interface HttpServerRequest extends HttpIncomingMessage.HttpIncomingMessage<HttpServerError> {
   readonly [TypeId]: typeof TypeId
-  readonly source: unknown
+  readonly source: object
   readonly url: string
   readonly originalUrl: string
   readonly method: HttpMethod

package/src/unstable/http/internal/preResponseHandler.ts

@@ -3,13 +3,13 @@ import type { PreResponseHandler } from "../HttpEffect.ts"
 import type { HttpServerRequest } from "../HttpServerRequest.ts"
 
 /** @internal */
-export const requestPreResponseHandlers = new WeakMap<HttpServerRequest, PreResponseHandler>()
+export const requestPreResponseHandlers = new WeakMap<object, PreResponseHandler>()
 
 /** @internal */
 export const appendPreResponseHandlerUnsafe = (request: HttpServerRequest, handler: PreResponseHandler): void => {
-  const prev = requestPreResponseHandlers.get(request)
+  const prev = requestPreResponseHandlers.get(request.source)
   const next: PreResponseHandler = prev ?
     (request, response) => Effect.flatMap(prev(request, response), (response) => handler(request, response))
     : handler
-  requestPreResponseHandlers.set(request, next)
+  requestPreResponseHandlers.set(request.source, next)
 }