effect 4.0.5 → 4.0.7

package/src/internal/schema/toRepresentation.ts

@@ -4,6 +4,7 @@ import * as SchemaAST from "../../SchemaAST.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import * as InternalRecord from "../record.ts"
 import * as InternalAnnotations from "./annotations.ts"
+import * as InternalContent from "./content.ts"
 
 const defaultReferencePolicy: SchemaRepresentation.ReferencePolicy = ({ identifier }) => identifier
 
@@ -15,9 +16,17 @@ interface ReferenceCandidate {
   readonly ast: SchemaAST.AST
   readonly identifier: string | undefined
   readonly fallback: string | undefined
+  readonly content: Content | undefined
   occurrences: number
-  isRecursive: boolean
-  reference: string | undefined
+  visiting?: boolean | undefined
+  isRecursive?: boolean | undefined
+  reference?: string | undefined
+  emitted?: boolean | undefined
+}
+
+interface Content {
+  readonly mediaType: string
+  readonly schema?: ReferenceCandidate | undefined
 }
 
 function annotationsField<A>(annotations: A | undefined): { readonly annotations: A } | undefined {
@@ -39,16 +48,14 @@ export function toRepresentations(
   options?: SchemaRepresentation.ToRepresentationOptions
 ): SchemaRepresentation.MultiDocument {
   const references: Record<string, SchemaRepresentation.Representation> = {}
-  const referenceOwners = new Map<string, ReferenceCandidate>()
-  const buildingReferences = new Set<string>()
-  const candidates = new Map<SchemaAST.AST, Map<string | undefined, ReferenceCandidate>>()
-  const visitingCandidates = new Set<ReferenceCandidate>()
+  const usedReferences = new Set<string>()
+  const candidates = new Map<SchemaAST.AST, Array<ReferenceCandidate>>()
 
   for (const ast of asts) visit(ast)
 
   const referencePolicy = options?.referencePolicy ?? defaultReferencePolicy
-  for (const candidatesByIdentifier of candidates.values()) {
-    for (const candidate of candidatesByIdentifier.values()) {
+  for (const variants of candidates.values()) {
+    for (const candidate of variants) {
       const requestedReference = referencePolicy({
         ast: candidate.ast,
         occurrences: candidate.occurrences,
@@ -59,25 +66,24 @@ export function toRepresentations(
             !requestedReference.endsWith("_")
           ? "_"
           : ""
-        candidate.reference = getReference(requestedReference, candidate, separator)
+        candidate.reference = getReference(requestedReference, separator)
       } else if (candidate.isRecursive) {
-        candidate.reference = getReference(`${candidate.ast._tag}_`, candidate, "")
+        candidate.reference = getReference(`${candidate.ast._tag}_`, "")
       }
     }
   }
 
-  const representations = Arr.map(asts, (ast) => recur(ast))
+  const representations = Arr.map(asts, recur)
 
   return { representations, references }
 
-  function getReference(prefix: string, owner: ReferenceCandidate, separator = "_"): string {
+  function getReference(prefix: string, separator: string): string {
     let candidate = prefix
     let suffix = 0
-    while (referenceOwners.has(candidate)) {
-      if (referenceOwners.get(candidate) === owner) return candidate
+    while (usedReferences.has(candidate)) {
       candidate = `${prefix}${separator}${++suffix}`
     }
-    referenceOwners.set(candidate, owner)
+    usedReferences.add(candidate)
     return candidate
   }
 
@@ -99,18 +105,27 @@ export function toRepresentations(
       : SchemaAST.annotate(ast, { identifier: reference })
   }
 
-  function makeReference(reference: string, ast: SchemaAST.AST): SchemaRepresentation.Reference {
-    if (!Object.hasOwn(references, reference) && !buildingReferences.has(reference)) {
-      buildingReferences.add(reference)
-      const representation = on(ast)
-      buildingReferences.delete(reference)
-      InternalRecord.assignProperty(references, reference, representation)
+  function getCandidate(
+    input: SchemaAST.AST,
+    encodingLength = input.encoding?.length ?? 0
+  ): ReferenceCandidate {
+    let ast = input
+    let content: Content | undefined
+    while (ast.encoding !== undefined && encodingLength > 0) {
+      const last = ast.encoding[encodingLength - 1]
+      // Only retain content when this operation produces the final string.
+      if (last.to.encoding === undefined && last.to._tag === "String") {
+        const metadata = InternalContent.getContent(last.transformation.encode)
+        if (metadata !== undefined) {
+          content = {
+            mediaType: metadata.mediaType,
+            schema: metadata.preserveSchema ? getCandidate(ast, encodingLength - 1) : undefined
+          }
+        }
+      }
+      ast = last.to
+      encodingLength = ast.encoding?.length ?? 0
     }
-    return { _tag: "Reference", $ref: reference }
-  }
-
-  function getCandidate(input: SchemaAST.AST): ReferenceCandidate {
-    const ast = SchemaAST.getLastEncoding(input)
     const owner = SchemaAST.getContextOwner(ast)
     let identifier = InternalAnnotations.resolveIdentifier(ast)
     const fallback = identifier === undefined
@@ -118,46 +133,48 @@ export function toRepresentations(
         InternalAnnotations.resolveIdentifierFallback(ast)
       : undefined
     if (fallback !== undefined) identifier = `${fallback}Encoded`
-    let candidatesByIdentifier = candidates.get(owner)
-    if (candidatesByIdentifier === undefined) {
-      candidatesByIdentifier = new Map()
-      candidates.set(owner, candidatesByIdentifier)
+    let variants = candidates.get(owner)
+    if (variants === undefined) {
+      variants = []
+      candidates.set(owner, variants)
     }
-    let candidate = candidatesByIdentifier.get(identifier)
+    let candidate = variants.find((candidate) =>
+      candidate.identifier === identifier &&
+      candidate.content?.mediaType === content?.mediaType &&
+      candidate.content?.schema === content?.schema
+    )
     if (candidate === undefined) {
       candidate = {
         ast: owner,
         identifier,
         fallback,
-        occurrences: 0,
-        isRecursive: false,
-        reference: undefined
+        content,
+        occurrences: 0
       }
-      candidatesByIdentifier.set(identifier, candidate)
+      variants.push(candidate)
     }
     return candidate
   }
 
-  function visit(input: SchemaAST.AST): void {
-    const candidate = getCandidate(input)
+  function visit(input: SchemaAST.AST): SchemaAST.AST {
+    visitCandidate(getCandidate(input))
+    return input
+  }
+
+  function visitCandidate(candidate: ReferenceCandidate): void {
     const ast = candidate.ast
     candidate.occurrences++
-    if (visitingCandidates.has(candidate)) {
+    if (candidate.visiting) {
       candidate.isRecursive = true
       return
     }
     if (candidate.occurrences > 1) return
-    visitingCandidates.add(candidate)
+    candidate.visiting = true
+    if (candidate.content?.schema !== undefined) visitCandidate(candidate.content.schema)
     visitChecks(ast.checks)
     switch (ast._tag) {
-      case "Declaration":
-      case "Arrays":
-      case "Objects":
-      case "Union":
-        ast.recur((child) => {
-          visit(child)
-          return child
-        })
+      default:
+        if ("recur" in ast) ast.recur(visit)
         break
       case "TemplateLiteral":
         ast.parts.forEach(visit)
@@ -166,7 +183,7 @@ export function toRepresentations(
         visit(ast.thunk())
         break
     }
-    visitingCandidates.delete(candidate)
+    candidate.visiting = false
   }
 
   function visitChecks(checks: SchemaAST.Checks | undefined): void {
@@ -177,74 +194,74 @@ export function toRepresentations(
   }
 
   function recur(input: SchemaAST.AST): SchemaRepresentation.Representation {
-    const candidate = getCandidate(input)
+    return recurCandidate(getCandidate(input))
+  }
+
+  function recurCandidate(candidate: ReferenceCandidate): SchemaRepresentation.Representation {
     const ast = candidate.ast
     const reference = candidate.reference
     if (reference !== undefined) {
-      const annotated = candidate.identifier === undefined ? ast : annotateReference(ast, candidate, reference)
-      return makeReference(reference, annotated)
+      if (!candidate.emitted) {
+        candidate.emitted = true
+        const annotated = candidate.identifier === undefined ? ast : annotateReference(ast, candidate, reference)
+        const representation = on(annotated, candidate.content)
+        InternalRecord.assignProperty(references, reference, representation)
+      }
+      return { _tag: "Reference", $ref: reference }
     }
-    return on(ast)
+    return on(ast, candidate.content)
   }
 
-  function on(ast: SchemaAST.AST): SchemaRepresentation.Representation {
-    const checks = fromChecks(ast.checks)
+  function on(ast: SchemaAST.AST, content: Content | undefined): SchemaRepresentation.Representation {
+    const common = {
+      checks: ast.checks?.map(fromCheck) ?? [],
+      ...(ast._tag === "Declaration" ? fromAnnotations(ast.annotations) : annotationsField(ast.annotations))
+    }
     switch (ast._tag) {
       case "Declaration":
         return {
-          _tag: "Declaration",
-          typeParameters: ast.typeParameters.map((ast) => recur(ast)),
-          checks,
-          ...fromDeclarationAnnotations(ast.annotations)
+          _tag: ast._tag,
+          typeParameters: ast.typeParameters.map(recur),
+          ...common
         }
-      case "Null":
-      case "Undefined":
-      case "Void":
-      case "Never":
-      case "Unknown":
-      case "Any":
-      case "String":
-      case "Boolean":
-      case "Number":
-      case "BigInt":
-      case "Symbol":
-      case "ObjectKeyword":
+      default:
         return {
           _tag: ast._tag,
-          checks,
-          ...annotationsField(ast.annotations)
+          ...(content === undefined ? undefined : {
+            content: {
+              mediaType: content.mediaType,
+              ...(content.schema === undefined ? undefined : { schema: recurCandidate(content.schema) })
+            }
+          }),
+          ...common
         }
       case "Literal":
         return {
-          _tag: "Literal",
+          _tag: ast._tag,
           literal: ast.literal,
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "UniqueSymbol":
         return {
-          _tag: "UniqueSymbol",
+          _tag: ast._tag,
           symbol: ast.symbol,
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "Enum":
         return {
-          _tag: "Enum",
+          _tag: ast._tag,
           enums: ast.enums,
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "TemplateLiteral":
         return {
-          _tag: "TemplateLiteral",
-          parts: ast.parts.map((ast) => recur(ast)),
-          checks,
-          ...annotationsField(ast.annotations)
+          _tag: ast._tag,
+          parts: ast.parts.map(recur),
+          ...common
         }
       case "Arrays":
         return {
-          _tag: "Arrays",
+          _tag: ast._tag,
           elements: ast.elements.map((element) => {
             const projected = SchemaAST.getLastEncoding(element)
             const annotations = projected.context?.annotations
@@ -254,13 +271,12 @@ export function toRepresentations(
               ...annotationsField(annotations)
             }
           }),
-          rest: ast.rest.map((ast) => recur(ast)),
-          checks,
-          ...annotationsField(ast.annotations)
+          rest: ast.rest.map(recur),
+          ...common
         }
       case "Objects":
         return {
-          _tag: "Objects",
+          _tag: ast._tag,
           propertySignatures: ast.propertySignatures.map((property) => {
             const projected = SchemaAST.getLastEncoding(property.type)
             const annotations = projected.context?.annotations
@@ -276,83 +292,49 @@ export function toRepresentations(
             parameter: recur(index.parameter),
             type: recur(index.type)
           })),
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "Union":
         return {
-          _tag: "Union",
-          types: ast.types.map((ast) => recur(ast)),
+          _tag: ast._tag,
+          types: ast.types.map(recur),
           ...(ast.options === undefined ? {} : { options: ast.options }),
-          checks,
-          ...annotationsField(ast.annotations)
+          ...common
         }
       case "Suspend":
         return {
-          _tag: "Suspend",
+          _tag: ast._tag,
+          ...common,
           checks: [],
-          thunk: recur(ast.thunk()),
-          ...annotationsField(ast.annotations)
+          thunk: recur(ast.thunk())
         }
     }
   }
 
-  function fromChecks(
-    checks: readonly [SchemaAST.Check<any>, ...Array<SchemaAST.Check<any>>] | undefined
-  ): Array<SchemaRepresentation.Check> {
-    return checks?.map(fromCheck) ?? []
-  }
-
   function fromCheck(
     check: SchemaAST.Check<any>
   ): SchemaRepresentation.Check {
-    switch (check._tag) {
-      case "Filter":
-        return {
-          _tag: "Filter",
-          aborted: check.aborted,
-          ...fromCheckAnnotations(check.annotations)
-        }
-      case "FilterGroup":
-        return {
-          _tag: "FilterGroup",
-          checks: Arr.map(check.checks, fromCheck),
-          ...fromCheckAnnotations(check.annotations)
-        }
-    }
-  }
-
-  function fromDeclarationAnnotations<
-    A extends Schema.Annotations.Annotations & {
-      readonly representation?: SchemaRepresentation.RepresentationAnnotation | undefined
-    }
-  >(annotations: A | undefined): {
-    readonly representation?: SchemaRepresentation.RepresentationAnnotation | undefined
-    readonly annotations?: Omit<A, "representation"> | undefined
-  } | undefined {
-    if (annotations === undefined) return undefined
-    const { representation, ...ordinary } = annotations
     return {
-      ...(representation === undefined ? undefined : { representation }),
-      ...(Object.keys(ordinary).length === 0 ? undefined : { annotations: ordinary })
+      ...(check._tag === "Filter"
+        ? { _tag: check._tag, aborted: check.aborted }
+        : { _tag: check._tag, checks: Arr.map(check.checks, fromCheck) }),
+      ...fromAnnotations(check.annotations, true)
     }
   }
 
-  function fromCheckAnnotations<
+  function fromAnnotations<
     A extends Schema.Annotations.Annotations & {
       readonly representation?: SchemaRepresentation.CheckRepresentationAnnotation<SchemaAST.AST> | undefined
     }
-  >(annotations: A | undefined): {
+  >(annotations: A | undefined, projectSchemas = false): {
     readonly representation?: CheckRepresentationAnnotation | undefined
     readonly annotations?: Omit<A, "representation"> | undefined
   } | undefined {
     if (annotations === undefined) return undefined
     const { representation, ...ordinary } = annotations
-    const projected = representation === undefined
-      ? undefined
-      : representation.schemas === undefined
-      ? representation as CheckRepresentationAnnotation
-      : { ...representation, schemas: representation.schemas.map((schema) => recur(SchemaAST.toType(schema))) }
+    const projected = projectSchemas && representation?.schemas !== undefined
+      ? { ...representation, schemas: representation.schemas.map((schema) => recur(SchemaAST.toType(schema))) }
+      : representation as CheckRepresentationAnnotation | undefined
     return {
       ...(projected === undefined ? undefined : { representation: projected }),
       ...(Object.keys(ordinary).length === 0 ? undefined : { annotations: ordinary })

package/src/internal/sql.ts

@@ -0,0 +1,14 @@
+import * as Context from "../Context.ts"
+
+/**
+ * The transaction service of the innermost transaction started with
+ * `SqlClient.makeWithTransaction`. `SqlResolver` reads it to find that
+ * transaction when the request's context has no `SqlClient` for it. Removing
+ * the service from a context also hides the transaction from this lookup.
+ *
+ * @internal
+ */
+export const CurrentTransactionService = Context.Reference<Context.Key<any, object> | undefined>(
+  "effect/sql/CurrentTransactionService",
+  { defaultValue: () => undefined }
+)

package/src/internal/trie.ts

@@ -79,7 +79,6 @@ const makeImpl = <V>(root: Node<V> | undefined): TrieImpl<V> => {
 
 class TrieIterator<in out V, out T> implements IterableIterator<T> {
   stack: Array<[Node<V>, string, boolean]> = []
-  readonly trie: TrieImpl<V>
   readonly f: TraversalMap<string, V, T>
   readonly filter: TraversalFilter<string, V>
 
@@ -88,7 +87,6 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
     f: TraversalMap<string, V, T>,
     filter: TraversalFilter<string, V>
   ) {
-    this.trie = trie
     this.f = f
     this.filter = filter
     const root = trie._root !== undefined ? trie._root : undefined
@@ -131,7 +129,7 @@ class TrieIterator<in out V, out T> implements IterableIterator<T> {
   }
 
   [Symbol.iterator](): IterableIterator<T> {
-    return new TrieIterator(this.trie, this.f, this.filter)
+    return this
   }
 }
 

package/src/internal/uuid.ts

@@ -1,16 +1,21 @@
-const hex = (byte: number): string => byte.toString(16).padStart(2, "0")
+const hex = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, "0"))
 
 /** @internal */
 export const stringify = (bytes: Uint8Array): string => {
-  const segments = [
-    bytes.subarray(0, 4),
-    bytes.subarray(4, 6),
-    bytes.subarray(6, 8),
-    bytes.subarray(8, 10),
-    bytes.subarray(10, 16)
-  ]
-
-  return segments.map((segment) => Array.from(segment, hex).join("")).join("-")
+  if (bytes.length < 16) {
+    return [
+      bytes.subarray(0, 4),
+      bytes.subarray(4, 6),
+      bytes.subarray(6, 8),
+      bytes.subarray(8, 10),
+      bytes.subarray(10, 16)
+    ].map((segment) => Array.from(segment, (byte) => hex[byte]).join("")).join("-")
+  }
+  return hex[bytes[0]] + hex[bytes[1]] + hex[bytes[2]] + hex[bytes[3]] + "-" +
+    hex[bytes[4]] + hex[bytes[5]] + "-" +
+    hex[bytes[6]] + hex[bytes[7]] + "-" +
+    hex[bytes[8]] + hex[bytes[9]] + "-" +
+    hex[bytes[10]] + hex[bytes[11]] + hex[bytes[12]] + hex[bytes[13]] + hex[bytes[14]] + hex[bytes[15]]
 }
 
 const randomBytes = (): Uint8Array<ArrayBuffer> => globalThis.crypto.getRandomValues(new Uint8Array(16))

package/src/internal/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = "4.0.5"
+export const version = "4.0.7"

package/src/net/NetAddress.ts

@@ -5,6 +5,7 @@
  * @since 4.0.0
  */
 import type * as Brand from "../Brand.ts"
+import * as Bytes from "../Bytes.ts"
 import * as Data from "../Data.ts"
 import * as Equal from "../Equal.ts"
 import { dual } from "../Function.ts"
@@ -770,7 +771,7 @@ const MacProto = {
   _tag: "MacAddress",
   [TypeId]: TypeId,
   [Equal.symbol](this: MacAddress, that: Equal.Equal): boolean {
-    return isMacAddress(that) && bytesEqual(getMacBytes(this), getMacBytes(that))
+    return isMacAddress(that) && Bytes.Equivalence(getMacBytes(this), getMacBytes(that))
   },
   [Hash.symbol](this: MacAddress): number {
     return Hash.combine(macHashSeed, Hash.array(getMacBytes(this)))
@@ -783,14 +784,6 @@ const MacProto = {
   }
 }
 
-const bytesEqual = (self: Uint8Array, that: Uint8Array): boolean => {
-  if (self.length !== that.length) return false
-  for (let index = 0; index < self.length; index++) {
-    if (self[index] !== that[index]) return false
-  }
-  return true
-}
-
 const ipv4HashSeed = Hash.string("Ipv4Address")
 const ipv6HashSeed = Hash.string("Ipv6Address")
 const macHashSeed = Hash.string("MacAddress")

package/src/observability/OtlpExporter.ts

@@ -22,27 +22,20 @@ import * as HttpClient from "../http/HttpClient.ts"
 import * as HttpClientError from "../http/HttpClientError.ts"
 import * as HttpClientRequest from "../http/HttpClientRequest.ts"
 import * as Layer from "../Layer.ts"
-import * as Num from "../Number.ts"
-import * as Option from "../Option.ts"
+import * as Result from "../Result.ts"
 import * as Schedule from "../Schedule.ts"
 import * as Scope from "../Scope.ts"
 import * as Version from "../Version.ts"
 
+// A missing or invalid Retry-After falls back to a fixed delay.
 const retryAfterDelay = (value: string | undefined): Effect.Effect<Duration.Duration> => {
-  const seconds = Option.fromUndefinedOr(value).pipe(Option.flatMap(Num.parse))
-  if (Option.isSome(seconds)) {
-    return Effect.succeed(Duration.seconds(seconds.value))
-  }
-  if (value === undefined) {
-    return Effect.succeed(Duration.seconds(5))
-  }
-  const timestamp = Date.parse(value)
-  if (Number.isNaN(timestamp)) {
+  const retryAfter = value === undefined ? undefined : Headers.parseRetryAfter(value)
+  if (retryAfter === undefined || Result.isFailure(retryAfter)) {
     return Effect.succeed(Duration.seconds(5))
   }
   return Effect.map(
     Clock,
-    (clock) => Duration.millis(Math.max(timestamp - clock.currentTimeMillisUnsafe(), 1))
+    (clock) => Headers.retryAfterDelay(retryAfter.success, clock.currentTimeMillisUnsafe())
   )
 }
 

package/src/observability/OtlpMetrics.ts

@@ -128,9 +128,11 @@ export const make: (options: {
     const currentSnapshotSequence = snapshotSequence++
     const nowNanos = clock.currentTimeNanosUnsafe()
     const nowTime = String(nowNanos)
-    const nextCounterState = new Map(previousCounterState)
-    const nextHistogramState = new Map(previousHistogramState)
-    const nextFrequencyState = new Map(previousFrequencyState)
+    // Only series in this snapshot carry their delta state forward, so removed
+    // series do not leak state or report a negative delta when recreated.
+    const nextCounterState = new Map<string, number | bigint>()
+    const nextHistogramState = new Map<string, PreviousHistogramState>()
+    const nextFrequencyState = new Map<string, Map<string, number>>()
     const metricData: Array<IMetric> = []
     const metricDataByName = new Map<string, IMetric>()
     const addMetricData = (data: IMetric) => {