effect 4.0.5 → 4.0.6

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.6"

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) => {

package/src/observability/OtlpResource.ts

@@ -170,13 +170,18 @@ export const entriesToAttributes = (entries: Iterable<[string, unknown]>): Array
   return attributes
 }
 
+// OTLP `intValue` is a signed 64-bit integer
+const int64Bound = 2 ** 63
+
 /**
  * Converts an arbitrary JavaScript value into an OTLP `AnyValue`.
  *
  * **Details**
  *
  * Arrays are converted recursively, primitive values use their matching OTLP
- * fields, and unsupported values are formatted as strings.
+ * fields, and unsupported values are formatted as strings. Integers outside the
+ * signed 64-bit range fall back to `doubleValue` for numbers and `stringValue`
+ * for bigints.
  *
  * @stability unstable
  * @category attributes
@@ -196,13 +201,18 @@ export const unknownToAttributeValue = (value: unknown): AnyValue => {
         stringValue: value
       }
     case "bigint":
-      return {
-        intValue: String(value)
-      }
+      return BigInt.asIntN(64, value) === value
+        ? {
+          intValue: String(value)
+        }
+        : {
+          stringValue: String(value)
+        }
     case "number":
-      return Number.isInteger(value)
+      return Number.isInteger(value) && value >= -int64Bound && value < int64Bound
         ? {
-          intValue: value
+          // Unsafe integers would be rounded when written as JSON numbers
+          intValue: Number.isSafeInteger(value) ? value : String(BigInt(value))
         }
         : {
           doubleValue: value

package/src/observability/OtlpSerialization.ts

@@ -30,17 +30,31 @@ export class OtlpSerialization extends Context.Service<OtlpSerialization, {
   readonly logs: (data: LogsData) => HttpBody.HttpBody
 }>()("effect/observability/OtlpSerialization") {}
 
+// OTLP/JSON writes NaN and Infinity as strings, but JSON.stringify writes null
+const nonFiniteToString = (_key: string, value: unknown) =>
+  typeof value === "number" && !Number.isFinite(value) ? String(value) : value
+
+const jsonBody = (data: unknown): HttpBody.HttpBody => {
+  const json = JSON.stringify(data)
+  return HttpBody.text(json.includes("null") ? JSON.stringify(data, nonFiniteToString) : json, "application/json")
+}
+
 /**
  * Provides `OtlpSerialization` using OTLP/HTTP JSON bodies.
  *
+ * **Details**
+ *
+ * `NaN`, `Infinity` and `-Infinity` are written as the strings OTLP/JSON
+ * expects, not as `null`.
+ *
  * @stability unstable
  * @category layers
  * @since 4.0.0
  */
 export const layerJson = Layer.succeed(OtlpSerialization, {
-  traces: (spans) => HttpBody.jsonUnsafe(spans),
-  metrics: (metrics) => HttpBody.jsonUnsafe(metrics),
-  logs: (logs) => HttpBody.jsonUnsafe(logs)
+  traces: (spans) => jsonBody(spans),
+  metrics: (metrics) => jsonBody(metrics),
+  logs: (logs) => jsonBody(logs)
 })
 
 /**

package/src/observability/internal/protobuf.ts

@@ -7,6 +7,7 @@
  * - 2: Length-delimited (string, bytes, embedded messages, packed repeated fields)
  * - 5: 32-bit (fixed32, sfixed32, float)
  */
+import * as Bytes from "../../Bytes.ts"
 
 const WireType = {
   Varint: 0,
@@ -101,16 +102,7 @@ export const encodeHexBytes = (hex: string): Uint8Array => {
  *
  * @internal
  */
-export const concat = (...arrays: Array<Uint8Array>): Uint8Array => {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0)
-  const result = new Uint8Array(totalLength)
-  let offset = 0
-  for (const arr of arrays) {
-    result.set(arr, offset)
-    offset += arr.length
-  }
-  return result
-}
+export const concat = (...arrays: Array<Uint8Array>): Uint8Array => Bytes.concat(arrays)
 
 // Field encoders
 

package/src/persistence/PersistedCache.ts

@@ -91,7 +91,9 @@ export const make: <
   })
   const inMemory = yield* Cache.makeWith(
     Effect.fnUntraced(function*(key: K) {
-      const exit = yield* (store.get(key) as Effect.Effect<Exit<Persistable.Success<K>, Persistable.Error<K>>>)
+      const exit = yield* (store.get(key).pipe(
+        Effect.catchTag("SchemaError", () => Effect.undefined)
+      ) as Effect.Effect<Exit<Persistable.Success<K>, Persistable.Error<K>> | undefined>)
       if (exit) {
         return yield* exit
       }