effect 4.0.3 → 4.0.4

package/src/internal/graphql.ts

@@ -0,0 +1,263 @@
+import { isReadonlyArrayNonEmpty, type NonEmptyReadonlyArray } from "../Array.ts"
+import * as Context from "../Context.ts"
+import * as Effect from "../Effect.ts"
+import type * as GraphQL from "../graphql/GraphQL.ts"
+import type { DocumentTemplate } from "../graphql/GraphQL.ts"
+import type { PartialResult } from "../graphql/GraphQLClient.ts"
+import {
+  DecodeError,
+  EncodeError,
+  GraphQLClientError,
+  type GraphQLError,
+  type Reason,
+  ResponseError
+} from "../graphql/GraphQLClientError.ts"
+import type { ExecutionResult, GraphQLRequest } from "../graphql/GraphQLProtocol.ts"
+import * as Schema from "../Schema.ts"
+
+/**
+ * Builds a response error with raw data and transport metadata.
+ *
+ * @internal
+ */
+export const responseError = (
+  result: ExecutionResult | undefined,
+  errors: NonEmptyReadonlyArray<GraphQLError>
+): ResponseError =>
+  new ResponseError({
+    errors,
+    ...(result?.data === undefined ? {} : { data: result.data as Schema.Json }),
+    ...(result?.extensions === undefined ? {} : { extensions: result.extensions }),
+    ...(result?.status === undefined ? {} : { status: result.status }),
+    ...(result?.headers === undefined ? {} : { headers: result.headers })
+  })
+
+/**
+ * Raw responses for partial results, used by resolvers to preserve error
+ * metadata. Mock client results have no entry.
+ *
+ * @internal
+ */
+export const partialResponses = new WeakMap<object, ExecutionResult>()
+
+/**
+ * Joins two printed pieces, adding a space only where two non-punctuators
+ * would otherwise touch. This is the generator printer's rule, so joining a
+ * generated template reproduces the printed document exactly.
+ */
+const concat = (left: string, right: string): string =>
+  /[\w"-]$/.test(left) && /^[\w"-]/.test(right) ? `${left} ${right}` : left + right
+
+const concatAll = (pieces: ReadonlyArray<string>): string => pieces.reduce(concat, "")
+
+/** Renders template parts, prefixing every name (the odd entries). */
+const renderParts = (parts: DocumentTemplate.Parts, prefix: string): string =>
+  parts.map((part, i) => i % 2 === 1 ? prefix + part : part).join("")
+
+const isShared = (fragment: DocumentTemplate.Fragment): boolean => fragment.body.length <= 1
+
+/**
+ * Renders the template once per prefix. The empty prefix renders it as
+ * written; any other prefix renames variables and per-slice fragments and
+ * aliases root fields to the prefixed response key.
+ */
+const render = (
+  kind: string,
+  name: string,
+  template: DocumentTemplate,
+  prefixes: ReadonlyArray<string>
+): string =>
+  concatAll([
+    kind,
+    name,
+    template.variables.length === 0 ? "" : `(${
+      concatAll(
+        prefixes.flatMap((prefix) =>
+          template.variables.map((variable) => `$${prefix}${variable.name}:${variable.body}`)
+        )
+      )
+    })`,
+    template.directives === undefined ? "" : renderParts(template.directives, ""),
+    `{${
+      concatAll(prefixes.flatMap((prefix) =>
+        template.selections.map((selection) => {
+          const key = prefix === "" ? selection.alias : `${prefix}${selection.alias ?? selection.name}`
+          return `${key === undefined ? "" : `${key}:`}${selection.name ?? ""}${renderParts(selection.body, prefix)}`
+        })
+      ))
+    }}`,
+    ...template.fragments.flatMap((fragment) =>
+      (isShared(fragment) ? [""] : prefixes).map((prefix) =>
+        concatAll(["fragment", prefix + fragment.name, renderParts(fragment.body, prefix)])
+      )
+    )
+  ])
+
+/**
+ * Joins a template into the document it was split from.
+ *
+ * @internal
+ */
+export const joinTemplate = (kind: string, name: string, template: DocumentTemplate): string =>
+  render(kind, name, template, [""])
+
+/**
+ * Why the template can't be sliced for any prefixes, if it can't: an operation
+ * directive references a variable, or a root selection is a fragment spread or
+ * inline fragment.
+ *
+ * @internal
+ */
+export const templateUnsliceableReason = (template: DocumentTemplate): string | undefined => {
+  if (template.directives !== undefined && template.directives.length > 1) {
+    return "its operation directives reference variables"
+  }
+  if (template.selections.some((selection) => selection.name === undefined)) {
+    return "it has a fragment spread or inline fragment at the root"
+  }
+  return undefined
+}
+
+/**
+ * Renders one operation that repeats the template once per prefix. Each
+ * slice's variables, root response keys and per-slice fragments are renamed
+ * with its prefix; operation directives and shared fragments appear once.
+ * Prefixes must start a GraphQL name, and none may be a prefix of another.
+ *
+ * Throws rather than producing an invalid document when the template is
+ * unsliceable (see {@link templateUnsliceableReason}) or a renamed fragment
+ * would take a shared fragment's name.
+ *
+ * @internal
+ */
+export const renderSlices = (
+  kind: string,
+  name: string,
+  template: DocumentTemplate,
+  prefixes: NonEmptyReadonlyArray<string>
+): string => {
+  const shared = new Set(template.fragments.filter(isShared).map((fragment) => fragment.name))
+  const collision = template.fragments
+    .flatMap((fragment) => isShared(fragment) ? [] : prefixes.map((prefix) => prefix + fragment.name))
+    .find((renamed) => shared.has(renamed))
+  const reason = templateUnsliceableReason(template) ??
+    (collision === undefined ? undefined : `fragment ${collision} would collide with a shared fragment`)
+  if (reason !== undefined) throw new Error(`Cannot render slices of operation ${name}: ${reason}`)
+  return render(kind, name, template, prefixes)
+}
+
+/**
+ * Forces POST for alias batches to avoid GET URL length limits.
+ *
+ * @internal
+ */
+export const ForcePost = Context.Reference<boolean>("effect/graphql/ForcePost", { defaultValue: () => false })
+
+/**
+ * JSON with object keys sorted, so equal JSON values give equal strings.
+ *
+ * @internal
+ */
+export const canonicalJson = (value: unknown): string =>
+  JSON.stringify(value, (_, value) =>
+    value !== null && typeof value === "object" && !Array.isArray(value)
+      ? Object.fromEntries(Object.keys(value).sort().map((key) => [key, value[key]]))
+      : value)
+
+/**
+ * Shared variable encoding, result decoding and client error mapping.
+ *
+ * @internal
+ */
+export const makeCodec = <Op extends GraphQL.Any>(operation: Op) => {
+  const fail = (reason: Reason) => new GraphQLClientError({ operation: operation.name, reason })
+  const schemaFail = (make: (description: string) => Reason) => (error: Schema.SchemaError) =>
+    Effect.fail(fail(make(error.message)))
+  const encode = Schema.encodeEffect(operation.variables)
+  const decode = Schema.decodeUnknownEffect(operation.result)
+
+  const encodeVariables = (
+    variables: GraphQL.Variables<Op> | undefined
+  ): Effect.Effect<unknown, GraphQLClientError, Op["variables"]["EncodingServices"]> =>
+    Effect.catch(encode(variables ?? {}), schemaFail((description) => new EncodeError({ description })))
+
+  const decodeData = (
+    data: unknown
+  ): Effect.Effect<GraphQL.Result<Op>, GraphQLClientError, Op["result"]["DecodingServices"]> =>
+    Effect.catch(decode(data), schemaFail((description) => new DecodeError({ description })))
+
+  // GraphQL requires errors when data is null or missing. Check before decoding,
+  // since schemas such as Schema.Json accept null.
+  const failResponse = (result: ExecutionResult): Effect.Effect<never, GraphQLClientError> => {
+    const errors = result.errors ?? []
+    return Effect.fail(fail(
+      isReadonlyArrayNonEmpty(errors)
+        ? responseError(result, errors)
+        : new DecodeError({ description: "data is null or missing without errors" })
+    ))
+  }
+
+  const decodeStrict = (
+    result: ExecutionResult
+  ): Effect.Effect<GraphQL.Result<Op>, GraphQLClientError, Op["result"]["DecodingServices"]> =>
+    isReadonlyArrayNonEmpty(result.errors ?? []) || result.data === null || result.data === undefined
+      ? failResponse(result)
+      : decodeData(result.data)
+
+  const decodePartial = (
+    result: ExecutionResult
+  ): Effect.Effect<PartialResult<GraphQL.Result<Op>>, GraphQLClientError, Op["result"]["DecodingServices"]> => {
+    if (result.data === null || result.data === undefined) return failResponse(result)
+    return Effect.map(decodeData(result.data), (data): PartialResult<GraphQL.Result<Op>> => {
+      const partial = { data, errors: result.errors ?? [] }
+      partialResponses.set(partial, result)
+      return partial
+    })
+  }
+
+  return { fail, schemaFail, encodeVariables, failResponse, decodeStrict, decodePartial } as const
+}
+
+/**
+ * Each real client method's runner for batches: its middleware and protocol,
+ * sending as POST. Mock and custom methods have none.
+ *
+ * @internal
+ */
+export const rawExecutors = new WeakMap<
+  object,
+  (request: GraphQLRequest) => Effect.Effect<ExecutionResult, unknown, unknown>
+>()
+
+/**
+ * Splits a batched response, removing prefixes from root keys and error paths.
+ * Returns undefined if an error matches no slice or data is null or missing.
+ *
+ * @internal
+ */
+export const splitSlices = (
+  result: ExecutionResult,
+  template: DocumentTemplate,
+  prefixes: ReadonlyArray<string>
+): ReadonlyArray<ExecutionResult> | undefined => {
+  const sliceErrors = prefixes.map((): Array<GraphQLError> => [])
+  for (const error of result.errors ?? []) {
+    const key = error.path?.[0]
+    // No prefix is a prefix of another, so at most one matches.
+    const index = typeof key === "string" ? prefixes.findIndex((prefix) => key.startsWith(prefix)) : -1
+    if (index === -1) return undefined
+    sliceErrors[index].push(
+      { ...error, path: [(key as string).slice(prefixes[index].length), ...error.path!.slice(1)] } as GraphQLError
+    )
+  }
+  if (result.data === null || result.data === undefined) return undefined
+  const data = result.data as Record<string, unknown>
+  return prefixes.map((prefix, i) => {
+    const sliceData: Record<string, unknown> = {}
+    for (const selection of template.selections) {
+      const key = (selection.alias ?? selection.name)!
+      if (Object.hasOwn(data, prefix + key)) sliceData[key] = data[prefix + key]
+    }
+    return { ...result, data: sliceData, errors: sliceErrors[i] }
+  })
+}

package/src/internal/graphqlHeaders.ts

@@ -0,0 +1,11 @@
+import * as Headers from "../http/Headers.ts"
+import * as Schema from "../Schema.ts"
+import * as SchemaGetter from "../SchemaGetter.ts"
+
+// Keep headers branded at runtime while encoding only their string entries.
+export const HeadersSchema = Schema.Record(Schema.String, Schema.String).pipe(
+  Schema.decodeTo(Schema.declare<Headers.Headers>(Headers.isHeaders), {
+    decode: SchemaGetter.transform(Headers.fromInput),
+    encode: SchemaGetter.transform((headers) => ({ ...headers }))
+  })
+)

package/src/internal/request.ts

@@ -4,6 +4,8 @@ import type { Effect } from "../Effect.ts"
 import type { Exit } from "../Exit.ts"
 import type { Fiber } from "../Fiber.ts"
 import { dual } from "../Function.ts"
+import * as MutableHashMap from "../MutableHashMap.ts"
+import * as Option from "../Option.ts"
 import type * as Request from "../Request.ts"
 import { makeEntry } from "../Request.ts"
 import type { RequestResolver } from "../RequestResolver.ts"
@@ -67,10 +69,36 @@ export const requestUnsafe = <A extends Request.Any>(
   return () => removeEntryUnsafe(options.resolver, entry)
 }
 
+/**
+ * Pending batches of resolvers whose `batchKey` is in this set match keys with
+ * `Equal` instead of by reference.
+ *
+ * @internal
+ */
+export const equalBatchKeys = new WeakSet<Function>()
+
+interface BatchMap {
+  get(key: unknown): Batch | undefined
+  has(key: unknown): boolean
+  set(key: unknown, batch: Batch): void
+  delete(key: unknown): void
+}
+
+const makeBatchMap = (resolver: RequestResolver<any>): BatchMap => {
+  if (!equalBatchKeys.has(resolver.batchKey)) return new Map()
+  const map = MutableHashMap.empty<unknown, Batch>()
+  return {
+    get: (key) => Option.getOrUndefined(MutableHashMap.get(map, key)),
+    has: (key) => MutableHashMap.has(map, key),
+    set: (key, batch) => MutableHashMap.set(map, key, batch),
+    delete: (key) => MutableHashMap.remove(map, key)
+  }
+}
+
 interface Batch {
   key: unknown
   resolver: RequestResolver<any>
-  map: Map<unknown, Batch>
+  map: BatchMap
   readonly entrySet: Set<Request.Entry<any>>
   readonly entries: Set<Request.Entry<any>>
   readonly delayEffect: Effect<void>
@@ -79,7 +107,7 @@ interface Batch {
 }
 
 const batchPool: Array<Batch> = []
-const pendingBatches = new WeakMap<RequestResolver<any>, Map<unknown, Batch>>()
+const pendingBatches = new WeakMap<RequestResolver<any>, BatchMap>()
 
 const addEntry = <A extends Request.Any>(
   resolver: RequestResolver<A>,
@@ -93,7 +121,7 @@ const addEntry = <A extends Request.Any>(
 ) => {
   let batchMap = pendingBatches.get(resolver)
   if (!batchMap) {
-    batchMap = new Map<object, Batch>()
+    batchMap = makeBatchMap(resolver)
     pendingBatches.set(resolver, batchMap)
   }
   let batch: Batch | undefined

package/src/internal/schema/toCodeDocument.ts

@@ -48,6 +48,8 @@ function renderEmittableAnnotation(input: unknown): string | undefined {
   return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`
 }
 
+const canonicalFiniteCheck = `Schema.isFinite().annotate({ "expected": "a finite number" })`
+
 function renderAnnotations(
   annotations: Schema.Annotations.Annotations | undefined
 ): string | undefined {
@@ -341,7 +343,11 @@ export function toCodeDocument(
     let runtime = base.runtime + runtimeAnnotate(representation.annotations)
     for (let index = 0; index < representation.checks.length; index++) {
       const check = representation.checks[index]
-      runtime += `.check(${compileCheck(check, [...path, "checks", index])})`
+      const compiledCheck = compileCheck(check, [...path, "checks", index])
+      // Only collapse a bare number's leading canonical check.
+      runtime = runtime === "Schema.Number" && compiledCheck === canonicalFiniteCheck
+        ? "Schema.Finite"
+        : `${runtime}.check(${compiledCheck})`
     }
     return makeCode(runtime, base.Type)
   }

package/src/internal/schema/toJsonSchemaDocument.ts

@@ -121,6 +121,37 @@ function hasNoCollisions(left: JsonSchema.JsonSchema, rightKeys: ReadonlyArray<s
   return typeof left.$ref !== "string" && rightKeys.every((key) => !Object.hasOwn(left, key))
 }
 
+// Every bound on one schema object applies, so a repeated bound reduces to its tighter value.
+const lowerBoundKeywords = "|minimum|exclusiveMinimum|minLength|minItems|minProperties|"
+const upperBoundKeywords = "|maximum|exclusiveMaximum|maxLength|maxItems|maxProperties|"
+
+// Tightens repeated bounds and drops an inclusive or exclusive bound implied by the other on the same side. Returns
+// `undefined` for a `$ref` schema or a non-bound collision, so the caller falls back to `allOf`.
+function mergeInlineCheck(
+  left: JsonSchema.JsonSchema,
+  right: JsonSchema.JsonSchema,
+  rightKeys: ReadonlyArray<string>
+): JsonSchema.JsonSchema | undefined {
+  if (typeof left.$ref === "string") return undefined
+  const out: JsonSchema.JsonSchema = { ...left, ...right }
+  for (const key of rightKeys) {
+    if (!Object.hasOwn(left, key)) continue
+    const a = left[key]
+    const b = right[key]
+    if (typeof a !== "number" || typeof b !== "number") return undefined
+    if (lowerBoundKeywords.includes(`|${key}|`)) out[key] = Math.max(a, b)
+    else if (upperBoundKeywords.includes(`|${key}|`)) out[key] = Math.min(a, b)
+    else return undefined
+  }
+  if (typeof out.minimum === "number" && typeof out.exclusiveMinimum === "number") {
+    delete out[out.exclusiveMinimum >= out.minimum ? "minimum" : "exclusiveMinimum"]
+  }
+  if (typeof out.maximum === "number" && typeof out.exclusiveMaximum === "number") {
+    delete out[out.exclusiveMaximum <= out.maximum ? "maximum" : "exclusiveMaximum"]
+  }
+  return out
+}
+
 // `format` and `content*` can affect validation, so they are not treated as pure annotations.
 const promotableAnnotationKeywords = "|title|description|default|examples|readOnly|writeOnly|"
 const inlineableAnnotatedCheckKeywords = inlineableCheckKeywords + promotableAnnotationKeywords
@@ -149,8 +180,9 @@ function appendJsonSchema(
         : appendJsonSchema(base, extracted.schema, inlineCheck)
     }
   }
-  if (inlineCheck && hasNoCollisions(left, rightKeys)) {
-    return { ...left, ...right }
+  if (inlineCheck) {
+    const merged = mergeInlineCheck(left, right, rightKeys)
+    if (merged !== undefined) return merged
   }
   const members = Array.isArray(right.allOf) && rightKeys.length === 1 ? right.allOf : [right]
   if (Array.isArray(left.allOf)) {

package/src/internal/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = "4.0.3"
+export const version = "4.0.4"

package/src/net/Host.ts

@@ -9,6 +9,7 @@
  * @stability experimental
  * @since 4.0.0
  */
+import type * as Arr from "../Array.ts"
 import type * as Brand from "../Brand.ts"
 import * as Equal from "../Equal.ts"
 import * as Hash from "../Hash.ts"
@@ -321,6 +322,28 @@ export const formatHost = (self: Host): string => typeof self === "string" ? sel
  */
 export const isFullyQualified = (self: DomainName): boolean => self.endsWith(".")
 
+/**
+ * Appends the trailing dot to a domain name, unless it is already fully
+ * qualified.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export const toFullyQualified = (self: DomainName): DomainName =>
+  isFullyQualified(self) ? self : `${self}.` as DomainName
+
+/**
+ * Removes the trailing dot of a fully qualified domain name, except from the
+ * root name `.`.
+ *
+ * @stability experimental
+ * @category converting
+ * @since 4.0.0
+ */
+export const toRelative = (self: DomainName): DomainName =>
+  self.length > 1 && isFullyQualified(self) ? self.slice(0, -1) as DomainName : self
+
 const HostPortProto = {
   ...Inspectable.BaseProto,
   _tag: "HostPort",
@@ -470,3 +493,52 @@ export const formatHostPort = (self: HostPort): string => {
   const host = formatHost(self.host)
   return host.includes(":") ? `[${host}]:${self.port}` : `${host}:${self.port}`
 }
+
+/**
+ * The addresses of host names, as read from a hosts file.
+ *
+ * @see {@link parseHostsFile} for reading a hosts file
+ * @stability experimental
+ * @category models
+ * @since 4.0.0
+ */
+export type HostsTable = ReadonlyMap<DomainName, Arr.NonEmptyReadonlyArray<NetAddress.IpAddress>>
+
+/**
+ * Parses a hosts file into the addresses of each host name. Invalid entries
+ * are skipped.
+ *
+ * **Example** (Parsing a hosts file)
+ *
+ * ```ts import.meta.vitest
+ * import { Host, NetAddress } from "effect/net"
+ *
+ * const hosts = Host.parseHostsFile(`
+ * 127.0.0.1 localhost
+ * ::1       localhost ip6-localhost # loopback
+ * `)
+ * hosts.get(Host.domainNameFromStringUnsafe("localhost"))?.map(NetAddress.formatIp) // => ["127.0.0.1", "::1"]
+ * ```
+ *
+ * @stability experimental
+ * @category decoding
+ * @since 4.0.0
+ */
+export const parseHostsFile = (text: string): HostsTable => {
+  const hosts = new Map<DomainName, Array<NetAddress.IpAddress>>()
+  for (const line of text.split(/\r?\n/)) {
+    const comment = line.indexOf("#")
+    const [first, ...names] = (comment === -1 ? line : line.slice(0, comment)).trim().split(/\s+/)
+    const address = NetAddress.ipFromString(first)
+    if (Result.isFailure(address)) continue
+    for (const name of names) {
+      const domain = domainNameFromString(name)
+      if (Result.isFailure(domain)) continue
+      const key = toRelative(domain.success)
+      const addresses = hosts.get(key)
+      if (addresses === undefined) hosts.set(key, [address.success])
+      else if (!addresses.some((existing) => Equal.equals(existing, address.success))) addresses.push(address.success)
+    }
+  }
+  return hosts as unknown as HostsTable
+}

package/src/net/NetAddress.ts

@@ -864,6 +864,15 @@ export const ipv4Loopback: Ipv4Address = makeIpv4(0x7f000001)
  */
 export const ipv6Loopback: Ipv6Address = makeIpv6(0, 0, 0, 1)
 
+/**
+ * The loopback addresses `127.0.0.1` and `::1`.
+ *
+ * @stability unstable
+ * @category constants
+ * @since 4.0.0
+ */
+export const loopbackAddresses: readonly [Ipv4Address, Ipv6Address] = [ipv4Loopback, ipv6Loopback]
+
 /**
  * The unspecified IPv4 address `0.0.0.0`.
  *

package/src/rpc/RpcServer.ts

@@ -494,6 +494,57 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   })
 })
 
+// Built-in JSON codecs depend only on the RPC schemas and can be shared.
+// Other factories may capture state at construction, so keep them per server.
+const isSharedCodecFor = (codecFor: RpcSerialization.CodecFor) => codecFor === RpcSerialization.json.codecFor
+
+interface RpcCodecs {
+  readonly decode: (u: unknown) => Effect.Effect<any, Schema.SchemaError>
+  readonly encodeChunk: (
+    u: NonEmptyReadonlyArray<unknown>
+  ) => Effect.Effect<NonEmptyReadonlyArray<unknown>, Schema.SchemaError>
+  readonly encodeExit: (u: unknown) => Effect.Effect<ResponseExitEncoded["exit"], Schema.SchemaError>
+}
+
+const sharedRpcCodecs = new WeakMap<Rpc.AnyWithProps, RpcCodecs>()
+
+const rpcCodecs = (codecFor: RpcSerialization.CodecFor, rpc: Rpc.AnyWithProps): RpcCodecs => {
+  const shared = isSharedCodecFor(codecFor)
+  let codecs = shared ? sharedRpcCodecs.get(rpc) : undefined
+  if (codecs === undefined) {
+    const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
+    codecs = {
+      decode: Schema.decodeUnknownEffect(codecFor(rpc.payloadSchema)) as any,
+      encodeChunk: Schema.encodeUnknownEffect(
+        codecFor(
+          Schema.NonEmptyArray(Option.isSome(streamSchemas) ? streamSchemas.value.success : Schema.Any)
+        )
+      ) as any,
+      encodeExit: Schema.encodeUnknownEffect(codecFor(Rpc.exitSchema(rpc as any))) as any
+    }
+    if (shared) sharedRpcCodecs.set(rpc, codecs)
+  }
+  return codecs
+}
+
+interface DefectCodecs {
+  readonly encodeDefectUnsafe: (defect: unknown) => unknown
+  readonly encodeUnknownRequestExit: (u: unknown) => Effect.Effect<ResponseExitEncoded["exit"], Schema.SchemaError>
+}
+
+let sharedDefectCodecs: DefectCodecs | undefined
+
+const makeDefectCodecs = (codecFor: RpcSerialization.CodecFor): DefectCodecs => ({
+  encodeDefectUnsafe: Schema.encodeSync(codecFor(Schema.Defect())),
+  // Unknown tags have no RPC schema, so use a defect-only exit schema.
+  encodeUnknownRequestExit: Schema.encodeUnknownEffect(
+    codecFor(Schema.Exit(Schema.Never, Schema.Never, Schema.Defect()))
+  ) as any
+})
+
+const defectCodecs = (codecFor: RpcSerialization.CodecFor): DefectCodecs =>
+  isSharedCodecFor(codecFor) ? (sharedDefectCodecs ??= makeDefectCodecs(codecFor)) : makeDefectCodecs(codecFor)
+
 // Merging the handler entry services with the request fiber services costs
 // O(services), so the merged context is cached per (entry, fiber context)
 // pair. Request fibers on persistent connections keep one context across
@@ -586,11 +637,7 @@ export const make: <Rpcs extends Rpc.Any>(
     supportsSpanPropagation,
     supportsTransferables
   } = yield* Protocol
-  const encodeDefectUnsafe = Schema.encodeSync(codecFor(Schema.Defect()))
-  // Unknown tags have no RPC schema, so use a defect-only exit schema.
-  const encodeUnknownRequestExit: Schemas["encodeExit"] = Schema.encodeUnknownEffect(
-    codecFor(Schema.Exit(Schema.Never, Schema.Never, Schema.Defect()))
-  ) as any
+  const { encodeDefectUnsafe, encodeUnknownRequestExit } = defectCodecs(codecFor)
   const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
   const scope = yield* Scope.make()
 
@@ -666,16 +713,9 @@ export const make: <Rpcs extends Rpc.Any>(
     let schemas = schemasCache.get(rpc)
     if (!schemas) {
       const entry = Context.getOrUndefinedUnsafe(services, rpc.key) as Rpc.Handler<Rpcs["_tag"]>
-      const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
       schemas = {
         tag: rpc._tag,
-        decode: Schema.decodeUnknownEffect(codecFor(rpc.payloadSchema)) as any,
-        encodeChunk: Schema.encodeUnknownEffect(
-          codecFor(
-            Schema.NonEmptyArray(Option.isSome(streamSchemas) ? streamSchemas.value.success : Schema.Any)
-          )
-        ) as any,
-        encodeExit: Schema.encodeUnknownEffect(codecFor(Rpc.exitSchema(rpc as any))) as any,
+        ...rpcCodecs(codecFor, rpc),
         context: entry.context
       }
       schemasCache.set(rpc, schemas)
@@ -1109,7 +1149,7 @@ export const makeProtocolWithHttpEffect: (
   RpcSerialization.RpcSerialization
 > = Effect.fnUntraced(function*(options = {}) {
   const serialization = yield* RpcSerialization.RpcSerialization
-  const encodeDefectUnsafe = Schema.encodeSync(serialization.codecFor(Schema.Defect()))
+  const { encodeDefectUnsafe } = defectCodecs(serialization.codecFor)
   const includesFraming = serialization.includesFraming
   const isBinary = !serialization.contentType.includes("json")
 
@@ -1569,7 +1609,7 @@ const makeSocketProtocol: Effect.Effect<
   RpcSerialization.RpcSerialization
 > = Effect.gen(function*() {
   const serialization = yield* RpcSerialization.RpcSerialization
-  const encodeDefectUnsafe = Schema.encodeSync(serialization.codecFor(Schema.Defect()))
+  const { encodeDefectUnsafe } = defectCodecs(serialization.codecFor)
   const disconnects = yield* Queue.make<number>()
 
   let clientId = 0

package/src/socket/Socket.ts

@@ -161,6 +161,12 @@ export interface Writer {
  * @since 4.0.0
  */
 export interface TlsUpgradeOptions {
+  /**
+   * DNS hostname used for Server Name Indication (SNI) and certificate identity
+   * verification during client upgrades. Server upgrades ignore this option.
+   * When omitted, the adapter retains its existing hostname behavior.
+   */
+  readonly servername?: string | undefined
   readonly key?:
     | Redacted.Redacted<string | Uint8Array>
     | ReadonlyArray<Redacted.Redacted<string | Uint8Array>>