effect 4.0.0-beta.93 → 4.0.0-beta.94

package/src/unstable/cli/Flag.ts

@@ -1782,7 +1782,7 @@ export const withSchema: {
    * @category schemas
    * @since 4.0.0
    */
-  <A, B>(schema: Schema.Codec<B, A, Environment, Environment>): (self: Flag<A>) => Flag<B>
+  <A, B>(schema: Schema.ConstraintCodec<B, A, Environment, unknown>): (self: Flag<A>) => Flag<B>
   /**
    * Validates and transforms a flag value using a Schema codec.
    *
@@ -1820,5 +1820,8 @@ export const withSchema: {
    * @category schemas
    * @since 4.0.0
    */
-  <A, B>(self: Flag<A>, schema: Schema.Codec<B, A, Environment, Environment>): Flag<B>
-} = dual(2, <A, B>(self: Flag<A>, schema: Schema.Codec<B, A>) => Param.withSchema(self, schema))
+  <A, B>(self: Flag<A>, schema: Schema.ConstraintCodec<B, A, Environment, unknown>): Flag<B>
+} = dual(
+  2,
+  <A, B>(self: Flag<A>, schema: Schema.ConstraintCodec<B, A, Environment, unknown>) => Param.withSchema(self, schema)
+)

package/src/unstable/cli/Param.ts

@@ -2430,7 +2430,7 @@ export const withSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <A, B>(schema: Schema.Codec<B, A, Environment, Environment>): <Kind extends ParamKind>(
+  <A, B>(schema: Schema.ConstraintCodec<B, A, Environment, unknown>): <Kind extends ParamKind>(
     self: Param<Kind, A>
   ) => Param<Kind, B>
   /**
@@ -2455,10 +2455,13 @@ export const withSchema: {
    * @category combinators
    * @since 4.0.0
    */
-  <Kind extends ParamKind, A, B>(self: Param<Kind, A>, schema: Schema.Codec<B, A, Environment, Environment>): Param<Kind, B>
+  <Kind extends ParamKind, A, B>(
+    self: Param<Kind, A>,
+    schema: Schema.ConstraintCodec<B, A, Environment, unknown>
+  ): Param<Kind, B>
 } = dual(2, <Kind extends ParamKind, A, B>(
   self: Param<Kind, A>,
-  schema: Schema.Codec<B, A>
+  schema: Schema.ConstraintCodec<B, A, Environment, unknown>
 ) => {
   const decodeParam = Schema.decodeUnknownEffect(schema)
   return mapEffect(self, (value) =>

package/src/unstable/cli/Primitive.ts

@@ -105,9 +105,9 @@ const makePrimitive = <A>(
     parse
   })
 
-const makeSchemaPrimitive = <T, E>(
+const makeSchemaPrimitive = <T>(
   tag: string,
-  schema: Schema.Codec<T, E, Environment, Environment>
+  schema: Schema.ConstraintDecoder<T, Environment>
 ): Primitive<T> => {
   const toCodecStringTree = Schema.toCodecStringTree(schema)
   const decode = Schema.decodeUnknownEffect(toCodecStringTree)

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -133,6 +133,7 @@ export const make = Effect.gen(function*() {
       if (!entity) {
         return yield* Effect.die(`Workflow ${workflowName} not registered`)
       }
+      yield* RcMap.invalidate(clientsPartial, workflowName)
       return yield* entity.client
     }),
     idleTimeToLive: "5 minutes"

package/src/unstable/cluster/Entity.ts

@@ -618,11 +618,7 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
       Rpc.ServicesClient<Rpcs> | Rpc.ServicesServer<Rpcs> | Rpc.Middleware<Rpcs> | LR
     >
     readonly concurrency: number | "unbounded"
-    readonly build: Effect.Effect<
-      Context.Context<Rpc.ToHandler<Rpcs>>,
-      never,
-      Scope | CurrentAddress
-    >
+    readonly build: Effect.Effect<Context.Context<Rpc.ToHandler<Rpcs>>>
   }>()
   const sharding = shardingTag.of({
     ...({} as Sharding["Service"]),
@@ -631,13 +627,7 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
         entityMap.set(entity.type, {
           context: context as any,
           concurrency: options?.concurrency ?? 1,
-          build: entity.protocol.toHandlers(handlers as any).pipe(
-            Effect.provideContext(Context.mutate(context, (context) =>
-              context.pipe(
-                Context.add(CurrentRunnerAddress, runnerAddress),
-                Context.omit(Scope)
-              )))
-          ) as any
+          build: entity.protocol.toHandlers(handlers as any) as any
         })
         return Effect.void
       })
@@ -654,8 +644,15 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
       entityId: entityId as EntityId,
       shardId: makeShardId(entityId)
     })
+    const scope = yield* Effect.scope
+    const handlerContext = Context.mutate(entityEntry.context, (context) =>
+      context.pipe(
+        Context.add(CurrentRunnerAddress, runnerAddress),
+        Context.add(CurrentAddress, address),
+        Context.add(Scope, scope)
+      ))
     const handlers = yield* entityEntry.build.pipe(
-      Effect.provideService(CurrentAddress, address)
+      Effect.setContext(handlerContext as Context.Context<any>)
     )
 
     // oxlint-disable-next-line prefer-const
@@ -665,7 +662,9 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
       onFromServer(response) {
         return client.write(response)
       }
-    }).pipe(Effect.provide(handlers))
+    }).pipe(
+      Effect.setContext(Context.merge(handlerContext, handlers))
+    )
 
     client = yield* RpcClient.makeNoSerialization(entity.protocol, {
       supportsAck: true,

package/src/unstable/cluster/Sharding.ts

@@ -1034,148 +1034,151 @@ const make = Effect.gen(function*() {
       MailboxFull | AlreadyProcessingMessage
     >,
     never
-  > = yield* ResourceMap.make(Effect.fnUntraced(function*(entity: Entity<string, any>) {
-    const client = yield* RpcClient.makeNoSerialization(entity.protocol, {
-      spanPrefix: `${entity.type}.client`,
-      disableTracing: !Context.get(entity.protocol.annotations, ClusterSchema.ClientTracingEnabled),
-      supportsAck: true,
-      generateRequestId: () => RequestId(snowflakeGen.nextUnsafe()),
-      flatten: true,
-      onFromClient(options): Effect.Effect<
-        void,
-        MailboxFull | AlreadyProcessingMessage | PersistenceError
-      > {
-        const address = Context.getUnsafe(options.context, ClientAddressTag)
-        switch (options.message._tag) {
-          case "Request": {
-            const fiber = Fiber.getCurrent()!
-            const id = Snowflake.Snowflake(options.message.id)
-            const rpc = entity.protocol.requests.get(options.message.tag)!
-            let respond: (reply: Reply.Reply<any>) => Effect.Effect<void>
-            const envelope = Envelope.makeRequest<any>({
-              requestId: id,
-              address,
-              tag: options.message.tag,
-              payload: options.message.payload,
-              headers: options.message.headers,
-              traceId: options.message.traceId,
-              spanId: options.message.spanId,
-              sampled: options.message.sampled
-            })
-            const message = new Message.OutgoingRequest({
-              envelope,
-              lastReceivedReply: Option.none(),
-              rpc,
-              context: fiber.context as Context.Context<any>,
-              respond: (reply) => respond(reply),
-              annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
-                rpc.annotations,
-                envelope as any
-              )
-            })
-            if (!options.discard) {
-              const entry: ClientRequestEntry = {
-                rpc: rpc as any,
-                context: fiber.currentContext,
-                message
+  > = yield* ResourceMap.make(
+    Effect.fnUntraced(function*(entity: Entity<string, any>) {
+      const client = yield* RpcClient.makeNoSerialization(entity.protocol, {
+        spanPrefix: `${entity.type}.client`,
+        disableTracing: !Context.get(entity.protocol.annotations, ClusterSchema.ClientTracingEnabled),
+        supportsAck: true,
+        generateRequestId: () => RequestId(snowflakeGen.nextUnsafe()),
+        flatten: true,
+        onFromClient(options): Effect.Effect<
+          void,
+          MailboxFull | AlreadyProcessingMessage | PersistenceError
+        > {
+          const address = Context.getUnsafe(options.context, ClientAddressTag)
+          switch (options.message._tag) {
+            case "Request": {
+              const fiber = Fiber.getCurrent()!
+              const id = Snowflake.Snowflake(options.message.id)
+              const rpc = entity.protocol.requests.get(options.message.tag)!
+              let respond: (reply: Reply.Reply<any>) => Effect.Effect<void>
+              const envelope = Envelope.makeRequest<any>({
+                requestId: id,
+                address,
+                tag: options.message.tag,
+                payload: options.message.payload,
+                headers: options.message.headers,
+                traceId: options.message.traceId,
+                spanId: options.message.spanId,
+                sampled: options.message.sampled
+              })
+              const message = new Message.OutgoingRequest({
+                envelope,
+                lastReceivedReply: Option.none(),
+                rpc,
+                context: fiber.context as Context.Context<any>,
+                respond: (reply) => respond(reply),
+                annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
+                  rpc.annotations,
+                  envelope as any
+                )
+              })
+              if (!options.discard) {
+                const entry: ClientRequestEntry = {
+                  rpc: rpc as any,
+                  context: fiber.currentContext,
+                  message
+                }
+                clientRequests.set(id, entry)
+                respond = makeClientRespond(entry, client.write)
+              } else {
+                respond = clientRespondDiscard
               }
-              clientRequests.set(id, entry)
-              respond = makeClientRespond(entry, client.write)
-            } else {
-              respond = clientRespondDiscard
+              return sendOutgoing(message, options.discard)
             }
-            return sendOutgoing(message, options.discard)
-          }
-          case "Ack": {
-            const requestId = Snowflake.Snowflake(options.message.requestId)
-            const entry = clientRequests.get(requestId)
-            if (!entry) return Effect.void
-            return sendOutgoing(
-              new Message.OutgoingEnvelope({
-                envelope: new Envelope.AckChunk({
-                  id: snowflakeGen.nextUnsafe(),
-                  address,
-                  requestId,
-                  replyId: entry.lastChunkId!
+            case "Ack": {
+              const requestId = Snowflake.Snowflake(options.message.requestId)
+              const entry = clientRequests.get(requestId)
+              if (!entry) return Effect.void
+              return sendOutgoing(
+                new Message.OutgoingEnvelope({
+                  envelope: new Envelope.AckChunk({
+                    id: snowflakeGen.nextUnsafe(),
+                    address,
+                    requestId,
+                    replyId: entry.lastChunkId!
+                  }),
+                  rpc: entry.rpc
                 }),
-                rpc: entry.rpc
-              }),
-              false
-            )
-          }
-          case "Interrupt": {
-            const requestId = Snowflake.Snowflake(options.message.requestId)
-            const entry = clientRequests.get(requestId)!
-            if (!entry) return Effect.void
-            clientRequests.delete(requestId)
-            if (ClusterSchema.isUninterruptibleForClient(entry.message.annotations)) {
-              return Effect.void
-            }
-            // for durable messages, we ignore interrupts on shutdown or as a
-            // result of a shard being resassigned
-            const isTransientInterrupt = MutableRef.get(isShutdown) ||
-              options.message.interruptors.some((id) => internalInterruptors.has(id))
-            if (isTransientInterrupt && Context.get(entry.message.annotations, Persisted)) {
-              return Effect.void
+                false
+              )
             }
-            return Effect.ignore(sendOutgoing(
-              new Message.OutgoingEnvelope({
-                envelope: new Envelope.Interrupt({
-                  id: snowflakeGen.nextUnsafe(),
-                  address,
-                  requestId
+            case "Interrupt": {
+              const requestId = Snowflake.Snowflake(options.message.requestId)
+              const entry = clientRequests.get(requestId)!
+              if (!entry) return Effect.void
+              clientRequests.delete(requestId)
+              if (ClusterSchema.isUninterruptibleForClient(entry.message.annotations)) {
+                return Effect.void
+              }
+              // for durable messages, we ignore interrupts on shutdown or as a
+              // result of a shard being resassigned
+              const isTransientInterrupt = MutableRef.get(isShutdown) ||
+                options.message.interruptors.some((id) => internalInterruptors.has(id))
+              if (isTransientInterrupt && Context.get(entry.message.annotations, Persisted)) {
+                return Effect.void
+              }
+              return Effect.ignore(sendOutgoing(
+                new Message.OutgoingEnvelope({
+                  envelope: new Envelope.Interrupt({
+                    id: snowflakeGen.nextUnsafe(),
+                    address,
+                    requestId
+                  }),
+                  rpc: entry.rpc
                 }),
-                rpc: entry.rpc
-              }),
-              false,
-              3
-            ))
+                false,
+                3
+              ))
+            }
           }
+          return Effect.void
         }
-        return Effect.void
-      }
-    })
-
-    yield* Scope.addFinalizer(
-      yield* Effect.scope,
-      Effect.withFiber((fiber) => {
-        internalInterruptors.add(fiber.id)
-        return Effect.void
       })
-    )
 
-    return (entityId: string) => {
-      const id = makeEntityId(entityId)
-      const address = ClientAddressTag.context(makeEntityAddress({
-        shardId: getShardId(id, entity.getShardGroup(entityId as EntityId)),
-        entityId: id,
-        entityType: entity.type
-      }))
-      const clientFn = function(tag: string, payload: any, options?: {
-        readonly context?: Context.Context<never>
-      }) {
-        const context = options?.context ? Context.merge(options.context, address) : address
-        return client.client(tag, payload, {
-          ...options,
-          context
+      yield* Scope.addFinalizer(
+        yield* Effect.scope,
+        Effect.withFiber((fiber) => {
+          internalInterruptors.add(fiber.id)
+          return Effect.void
         })
-      }
-      const proxyClient: any = {}
-      return new Proxy(proxyClient, {
-        has(_, p) {
-          return entity.protocol.requests.has(p as string)
-        },
-        get(target, p) {
-          if (p in target) {
-            return target[p]
-          } else if (!entity.protocol.requests.has(p as string)) {
-            return undefined
-          }
-          return target[p] = (payload: any, options?: {}) => clientFn(p as string, payload, options)
+      )
+
+      return (entityId: string) => {
+        const id = makeEntityId(entityId)
+        const address = ClientAddressTag.context(makeEntityAddress({
+          shardId: getShardId(id, entity.getShardGroup(entityId as EntityId)),
+          entityId: id,
+          entityType: entity.type
+        }))
+        const clientFn = function(tag: string, payload: any, options?: {
+          readonly context?: Context.Context<never>
+        }) {
+          const context = options?.context ? Context.merge(options.context, address) : address
+          return client.client(tag, payload, {
+            ...options,
+            context
+          })
         }
-      })
-    }
-  }))
+        const proxyClient: any = {}
+        return new Proxy(proxyClient, {
+          has(_, p) {
+            return entity.protocol.requests.has(p as string)
+          },
+          get(target, p) {
+            if (p in target) {
+              return target[p]
+            } else if (!entity.protocol.requests.has(p as string)) {
+              return undefined
+            }
+            return target[p] = (payload: any, options?: {}) => clientFn(p as string, payload, options)
+          }
+        })
+      }
+    }),
+    { referential: true }
+  )
 
   const makeClient = <Type extends string, Rpcs extends Rpc.Any>(entity: Entity<Type, Rpcs>): Effect.Effect<
     (

package/src/unstable/cluster/internal/entityManager.ts

@@ -155,16 +155,18 @@ export const make = Effect.fnUntraced(function*<
       Effect.fnUntraced(function*(scope) {
         let isShuttingDown = false
 
+        const handlerContext = Context.mutate(context, (context) =>
+          context.pipe(
+            Context.add(CurrentAddress, address),
+            Context.add(CurrentRunnerAddress, options.runnerAddress),
+            Context.add(KeepAliveLatch, keepAliveLatch),
+            Context.add(Scope.Scope, scope),
+            Context.add(CurrentLogAnnotations, {})
+          ))
+
         // Initiate the behavior for the entity
         const handlers = yield* (entity.protocol.toHandlers(buildHandlers as any).pipe(
-          Effect.provideService(CurrentLogAnnotations, {}),
-          Effect.provideContext(Context.mutate(context, (context) =>
-            context.pipe(
-              Context.add(CurrentAddress, address),
-              Context.add(CurrentRunnerAddress, options.runnerAddress),
-              Context.add(KeepAliveLatch, keepAliveLatch),
-              Context.add(Scope.Scope, scope)
-            ))),
+          Effect.setContext(handlerContext as Context.Context<any>),
           Effect.sandbox,
           Effect.tapError((cause) => Effect.logError("Defect building entity handlers", cause)),
           Effect.retry(defectRetryPolicy)
@@ -280,7 +282,7 @@ export const make = Effect.fnUntraced(function*<
           }
         }).pipe(
           Scope.provide(scope),
-          Effect.provideContext(handlers)
+          Effect.setContext(Context.merge(handlerContext, handlers))
         )
 
         yield* Scope.addFinalizer(

package/src/unstable/cluster/internal/resourceMap.ts

@@ -4,23 +4,16 @@ import * as Effect from "../../../Effect.ts"
 import * as Exit from "../../../Exit.ts"
 import * as MutableHashMap from "../../../MutableHashMap.ts"
 import * as MutableRef from "../../../MutableRef.ts"
-import * as Option from "../../../Option.ts"
 import * as Scope from "../../../Scope.ts"
 
 /** @internal */
 export class ResourceMap<K, A, E> {
   readonly lookup: (key: K, scope: Scope.Scope) => Effect.Effect<A, E>
-  readonly entries: MutableHashMap.MutableHashMap<K, {
-    readonly scope: Scope.Closeable
-    readonly deferred: Deferred.Deferred<A, E>
-  }>
+  readonly entries: BackingMap<K, A, E>
   readonly isClosed: MutableRef.MutableRef<boolean>
   constructor(
     lookup: (key: K, scope: Scope.Scope) => Effect.Effect<A, E>,
-    entries: MutableHashMap.MutableHashMap<K, {
-      readonly scope: Scope.Closeable
-      readonly deferred: Deferred.Deferred<A, E>
-    }>,
+    entries: BackingMap<K, A, E>,
     isClosed: MutableRef.MutableRef<boolean>
   ) {
     this.lookup = lookup
@@ -28,22 +21,29 @@ export class ResourceMap<K, A, E> {
     this.isClosed = isClosed
   }
 
-  static make = Effect.fnUntraced(function*<K, A, E, R>(lookup: (key: K) => Effect.Effect<A, E, R>) {
+  static make = Effect.fnUntraced(function*<K, A, E, R>(lookup: (key: K) => Effect.Effect<A, E, R>, options?: {
+    readonly referential?: boolean | undefined
+  }) {
     const scope = yield* Effect.scope
     const services = yield* Effect.context<R>()
     const isClosed = MutableRef.make(false)
 
-    const entries = MutableHashMap.empty<K, {
-      scope: Scope.Closeable
-      deferred: Deferred.Deferred<A, E>
-    }>()
+    const entries: BackingMap<K, A, E> = options?.referential ?
+      {
+        _tag: "Referential",
+        map: new Map()
+      } :
+      {
+        _tag: "Equal",
+        map: MutableHashMap.empty()
+      }
 
     yield* Scope.addFinalizerExit(
       scope,
       (exit) => {
         MutableRef.set(isClosed, true)
-        return Effect.forEach(entries, ([key, { scope }]) => {
-          MutableHashMap.remove(entries, key)
+        return Effect.forEach(entries.map, ([key, { scope }]) => {
+          backingDelete(entries, key)
           return Effect.exit(Scope.close(scope, exit))
         }, { concurrency: "unbounded", discard: true })
       }
@@ -61,18 +61,18 @@ export class ResourceMap<K, A, E> {
       if (MutableRef.get(this.isClosed)) {
         return Effect.interrupt
       }
-      const existing = MutableHashMap.get(this.entries, key)
-      if (Option.isSome(existing)) {
-        return Deferred.await(existing.value.deferred)
+      const existing = backingGet(this.entries, key)
+      if (existing) {
+        return Deferred.await(existing.deferred)
       }
       const scope = Effect.runSync(Scope.make())
       const deferred = Deferred.makeUnsafe<A, E>()
-      MutableHashMap.set(this.entries, key, { scope, deferred })
+      backingSet(this.entries, key, { scope, deferred })
       return Effect.onExit(this.lookup(key, scope), (exit) => {
         if (exit._tag === "Success") {
           return Deferred.done(deferred, exit)
         }
-        MutableHashMap.remove(this.entries, key)
+        backingDelete(this.entries, key)
         return Deferred.done(deferred, exit)
       })
     })
@@ -80,12 +80,12 @@ export class ResourceMap<K, A, E> {
 
   remove(key: K): Effect.Effect<void> {
     return Effect.suspend(() => {
-      const entry = MutableHashMap.get(this.entries, key)
-      if (Option.isNone(entry)) {
+      const entry = backingGet(this.entries, key)
+      if (!entry) {
         return Effect.void
       }
-      MutableHashMap.remove(this.entries, key)
-      return Scope.close(entry.value.scope, Exit.void)
+      backingDelete(this.entries, key)
+      return Scope.close(entry.scope, Exit.void)
     })
   }
 
@@ -98,3 +98,37 @@ export class ResourceMap<K, A, E> {
       }))
   }
 }
+
+type BackingMap<K, A, E> = {
+  readonly _tag: "Equal"
+  readonly map: MutableHashMap.MutableHashMap<K, Entry<A, E>>
+} | {
+  readonly _tag: "Referential"
+  readonly map: Map<K, Entry<A, E>>
+}
+
+type Entry<A, E> = {
+  readonly scope: Scope.Closeable
+  readonly deferred: Deferred.Deferred<A, E>
+}
+
+const backingGet = <K, A, E>(map: BackingMap<K, A, E>, key: K): Entry<A, E> | undefined => {
+  if (map._tag === "Equal") {
+    return MutableHashMap.get(map.map, key).valueOrUndefined
+  }
+  return map.map.get(key)
+}
+const backingSet = <K, A, E>(map: BackingMap<K, A, E>, key: K, entry: Entry<A, E>): void => {
+  if (map._tag === "Equal") {
+    MutableHashMap.set(map.map, key, entry)
+  } else {
+    map.map.set(key, entry)
+  }
+}
+const backingDelete = <K, A, E>(map: BackingMap<K, A, E>, key: K): void => {
+  if (map._tag === "Equal") {
+    MutableHashMap.remove(map.map, key)
+  } else {
+    map.map.delete(key)
+  }
+}

package/src/unstable/encoding/Sse.ts

@@ -80,15 +80,15 @@ export const decode = <IE, Done>(): Channel.Channel<
  * @since 4.0.0
  */
 export interface EventCodec extends
-  Schema.Codec<
+  Schema.ConstraintCodec<
     any,
     {
       readonly id?: string | undefined
       readonly event?: string | undefined
       readonly data: string
     },
-    any,
-    any
+    unknown,
+    unknown
   >
 {}
 

package/src/unstable/http/HttpClientResponse.ts

@@ -93,10 +93,9 @@ export const schemaJson = <
     readonly headers?: Readonly<Record<string, string | undefined>> | undefined
     readonly body?: unknown
   },
-  RD,
-  RE
+  RD
 >(
-  schema: Schema.Codec<A, I, RD, RE>,
+  schema: Schema.ConstraintCodec<A, I, RD, unknown>,
   options?: ParseOptions | undefined
 ) => {
   const decode = Schema.decodeEffect(Schema.toCodecJson(schema).annotate({ options }))

package/src/unstable/http/HttpIncomingMessage.ts

@@ -78,10 +78,9 @@ export const schemaBodyJson = <S extends Schema.Constraint>(schema: S, options?:
 export const schemaBodyUrlParams = <
   A,
   I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>,
-  RD,
-  RE
+  RD
 >(
-  schema: Schema.Codec<A, I, RD, RE>,
+  schema: Schema.ConstraintCodec<A, I, RD, unknown>,
   options?: ParseOptions | undefined
 ) => {
   const decode = UrlParams.schemaRecord.pipe(
@@ -98,8 +97,8 @@ export const schemaBodyUrlParams = <
  * @category schemas
  * @since 4.0.0
  */
-export const schemaHeaders = <A, I extends Readonly<Record<string, string | undefined>>, RD, RE>(
-  schema: Schema.Codec<A, I, RD, RE>,
+export const schemaHeaders = <A, I extends Readonly<Record<string, string | undefined>>, RD>(
+  schema: Schema.ConstraintCodec<A, I, RD, unknown>,
   options?: ParseOptions | undefined
 ) => {
   const decode = Schema.decodeUnknownEffect(schema)