effect 4.1.0 → 4.1.2

package/src/jose/internal/compact.ts

@@ -0,0 +1,195 @@
+import type * as CryptoError from "../../crypto/CryptoError.ts"
+import * as Duration from "../../Duration.ts"
+import * as Effect from "../../Effect.ts"
+import * as Base64Url from "../../encoding/Base64Url.ts"
+import * as Option from "../../Option.ts"
+import * as Redacted from "../../Redacted.ts"
+import * as Result from "../../Result.ts"
+import * as Schema from "../../Schema.ts"
+import * as JoseError from "../JoseError.ts"
+
+/** @internal */
+export const fail = (reason: JoseError.JoseErrorReason): Effect.Effect<never, JoseError.JoseError> =>
+  Effect.fail(new JoseError.JoseError({ reason }))
+
+/** @internal */
+export const invalidToken = (description: string) => fail(new JoseError.InvalidToken({ description }))
+
+/** @internal */
+export const invalidKey = (description: string, cause?: unknown) =>
+  fail(new JoseError.InvalidKey({ description, cause }))
+
+/** @internal */
+export const invalidArgument = (description: string, cause?: unknown) =>
+  fail(new JoseError.InvalidArgument({ description, cause }))
+
+/**
+ * Maps a failure of an operation on secret material, such as signing or
+ * private-key import, to a fixed description. Backend messages and causes may
+ * describe the secret, so they are dropped.
+ *
+ * @internal
+ */
+export const cryptoFailure = (description: string) => (_: CryptoError.CryptoError): JoseError.JoseError =>
+  new JoseError.JoseError({ reason: new JoseError.InvalidKey({ description }) })
+
+/**
+ * Maps a public-key import failure, keeping the backend diagnostic.
+ *
+ * @internal
+ */
+export const publicKeyFailure = (error: CryptoError.CryptoError): JoseError.JoseError =>
+  new JoseError.JoseError({ reason: new JoseError.InvalidKey({ description: error.message, cause: error }) })
+
+/**
+ * Schema fields that keep private and symmetric key members out of a public
+ * JWK.
+ *
+ * @internal
+ */
+export const noPrivateMembers = {
+  d: Schema.optionalKey(Schema.Never),
+  p: Schema.optionalKey(Schema.Never),
+  q: Schema.optionalKey(Schema.Never),
+  dp: Schema.optionalKey(Schema.Never),
+  dq: Schema.optionalKey(Schema.Never),
+  qi: Schema.optionalKey(Schema.Never),
+  oth: Schema.optionalKey(Schema.Never),
+  k: Schema.optionalKey(Schema.Never)
+}
+
+/** @internal */
+export const hasPrivateMembers = (jwk: object): boolean =>
+  Object.keys(noPrivateMembers).some((name) => Object.hasOwn(jwk, name))
+
+/** @internal */
+export const utf8 = (text: string): Uint8Array => new TextEncoder().encode(text)
+
+/** @internal */
+export const reveal = (token: string | Redacted.Redacted<string>): string =>
+  Redacted.isRedacted(token) ? Redacted.value(token) : token
+
+/**
+ * Checks unpadded base64url, including the unused bits in the final character.
+ *
+ * @internal
+ */
+export const isCanonicalSegment = (segment: string): boolean => {
+  if (/[^A-Za-z0-9_-]/.test(segment)) return false
+  const remainder = segment.length % 4
+  const last = segment.charAt(segment.length - 1)
+  return remainder === 0 ||
+    (remainder === 2 ? "AQgw".includes(last) : remainder === 3 && "AEIMQUYcgkosw048".includes(last))
+}
+
+/**
+ * Decodes canonical unpadded base64url.
+ *
+ * @internal
+ */
+export const decodeSegment = (segment: string): Uint8Array | undefined => {
+  if (!isCanonicalSegment(segment)) return undefined
+  const decoded = Base64Url.decode(segment)
+  return Result.isSuccess(decoded) ? decoded.success : undefined
+}
+
+/** @internal */
+export const parseJsonObject = (bytes: Uint8Array): Readonly<Record<string, Schema.Json>> | undefined => {
+  try {
+    const value: unknown = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes))
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+      ? value as Readonly<Record<string, Schema.Json>>
+      : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Splits a compact serialization into exactly `count` segments.
+ *
+ * @internal
+ */
+export const split = (
+  token: string | Redacted.Redacted<string>,
+  count: number
+): Effect.Effect<ReadonlyArray<string>, JoseError.JoseError> => {
+  const parts = reveal(token).split(".")
+  return parts.length === count
+    ? Effect.succeed(parts)
+    : invalidToken(`A compact serialization must have ${count} segments`)
+}
+
+/**
+ * Decodes a protected header. Parameters in `unsupported` change how the
+ * token is processed, so they are rejected rather than ignored.
+ *
+ * @internal
+ */
+export const decodeHeader = <A>(
+  segment: string,
+  decode: (input: unknown) => Option.Option<A>,
+  unsupported: ReadonlyArray<string>
+): Effect.Effect<A, JoseError.JoseError> => {
+  const bytes = decodeSegment(segment)
+  const json = bytes === undefined ? undefined : parseJsonObject(bytes)
+  if (json === undefined) return invalidToken("The protected header is not a base64url JSON object")
+  for (const name of unsupported) {
+    if (Object.hasOwn(json, name)) return invalidToken(`The ${name} header parameter is not supported`)
+  }
+  return Option.match(decode(json), {
+    onNone: () => invalidToken("The protected header has unsupported or malformed parameters"),
+    onSome: Effect.succeed
+  })
+}
+
+/**
+ * Base64url-encodes a protected header. Fixed parameters come first and
+ * cannot be overridden by additional parameters.
+ *
+ * @internal
+ */
+export const encodeHeader = (
+  fixed: Readonly<Record<string, string>>,
+  kid: string | undefined,
+  header: { readonly kid?: string | undefined } | undefined,
+  unsupported: ReadonlyArray<string>
+): Effect.Effect<string, JoseError.JoseError> => {
+  for (const name of unsupported) {
+    if (header !== undefined && Object.hasOwn(header, name)) {
+      return invalidArgument(`The ${name} header parameter is not supported`)
+    }
+  }
+  const { kid: headerKid, ...rest } = header ?? {}
+  const value = { ...fixed, kid: headerKid ?? kid, ...rest, ...fixed }
+  try {
+    return Effect.succeed(Base64Url.encode(JSON.stringify(value)))
+  } catch {
+    return invalidArgument("The protected header is not JSON serializable")
+  }
+}
+
+/**
+ * Reads a finite, non-negative duration in milliseconds.
+ *
+ * @internal
+ */
+export const millis = (name: string, input: Duration.Input): Effect.Effect<number, JoseError.JoseError> => {
+  const value = hasInvalidComponent(input) ? Option.none() : Option.map(Duration.fromInput(input), Duration.toMillis)
+  return Option.isSome(value) && Number.isFinite(value.value) && value.value >= 0
+    ? Effect.succeed(value.value)
+    : invalidArgument(`${name} must be a finite, non-negative duration`)
+}
+
+// `Duration` reads NaN as zero in every input form, and components that are
+// not finite or overflow on conversion add up to NaN. Either would silently
+// disable a bound.
+const hasInvalidComponent = (input: Duration.Input): boolean => {
+  if (typeof input === "number") return Number.isNaN(input)
+  if (typeof input !== "object" || Duration.isDuration(input)) return false
+  if (Array.isArray(input)) return input.some((component) => !Number.isFinite(component))
+  return Object.entries(input).some(([unit, component]) =>
+    typeof component === "number" &&
+    (!Number.isFinite(component) || !Number.isFinite(Duration.toMillis({ [unit]: component })))
+  )
+}

package/src/net/Host.ts

@@ -111,7 +111,8 @@ export type HostPortInput = HostPort | string | HostPortParts
 const hostError = (input: unknown, message: string): Result.Result<never, NetAddress.NetAddressError> =>
   Result.fail(new NetAddress.NetAddressError({ input, message }))
 
-const asciiNameCharacter = /^[a-z0-9_.-]$/i
+const asciiName = /^[a-z0-9_.-]*$/i
+const nonAscii = /[\u0080-\uffff]/g
 const labelPattern = /^[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?$/
 const numericLabel = /^(?:\d+|0x[0-9a-f]*)$/
 
@@ -135,15 +136,9 @@ const validateDomainName = (name: string): string | undefined => {
 }
 
 const toAsciiDomainName = (input: string): string | undefined => {
-  let ascii = true
-  for (const character of input) {
-    if (character.charCodeAt(0) < 0x80) {
-      if (!asciiNameCharacter.test(character)) return undefined
-    } else {
-      ascii = false
-    }
-  }
-  if (ascii) return input.toLowerCase()
+  if (asciiName.test(input)) return input.toLowerCase()
+  // Check the composed form, so that `=\u0338` is read as `≠`
+  if (!asciiName.test(input.normalize("NFC").replace(nonAscii, ""))) return undefined
   try {
     return new URL(`http://${input}`).hostname
   } catch {

package/src/observability/OtlpExporter.ts

@@ -21,6 +21,7 @@ import type { HttpBody } from "../http/HttpBody.ts"
 import * as HttpClient from "../http/HttpClient.ts"
 import * as HttpClientError from "../http/HttpClientError.ts"
 import * as HttpClientRequest from "../http/HttpClientRequest.ts"
+import * as Latch from "../Latch.ts"
 import * as Layer from "../Layer.ts"
 import * as Result from "../Result.ts"
 import * as Schedule from "../Schedule.ts"
@@ -154,6 +155,10 @@ export const layerFlusher: Layer.Layer<Flusher> = Layer.sync(Flusher, () => {
  * after unhandled failures, and flushes during scope finalization up to
  * `shutdownTimeout`.
  *
+ * The export interval starts with the first push and stops once an export
+ * empties the buffer, so an idle exporter keeps no timer pending. With
+ * `exportEmpty` and batching disabled, it exports on every interval instead.
+ *
  * Optional gzip compression uses `HttpClientRequest.compressBody` before the
  * retry loop, so retries reuse the compressed bytes. Bodies smaller than 1KB
  * remain uncompressed. Compression requires runtime `CompressionStream` support;
@@ -186,7 +191,6 @@ export const make: (
   const clock = Context.get(services, Clock)
   const scope = Context.get(services, Scope.Scope)
   const exportInterval = Duration.max(Duration.fromInputUnsafe(options.exportInterval), Duration.zero)
-  let disabledUntil: number | undefined = undefined
 
   const client = Context.get(services, HttpClient.HttpClient).pipe(
     HttpClient.tap((response) => Effect.ignore(response.arrayBuffer)),
@@ -206,14 +210,18 @@ export const make: (
   )
 
   const request = HttpClientRequest.post(options.url, { headers })
+  const exportsEmpty = options.maxBatchSize === "disabled" && options.exportEmpty === true
   let buffer: Array<any> = []
+  let disabledUntil: number | undefined = undefined
+  const isDisabled = () => {
+    if (disabledUntil === undefined) return false
+    if (clock.currentTimeMillisUnsafe() < disabledUntil) return true
+    disabledUntil = undefined
+    return false
+  }
+
   const runExport = Effect.suspend(() => {
-    if (disabledUntil !== undefined && clock.currentTimeMillisUnsafe() < disabledUntil) {
-      return Effect.void
-    } else if (disabledUntil !== undefined) {
-      disabledUntil = undefined
-    }
-    if (buffer.length === 0 && (options.maxBatchSize !== "disabled" || options.exportEmpty !== true)) {
+    if (isDisabled() || (buffer.length === 0 && !exportsEmpty)) {
       return Effect.void
     }
     const items = buffer
@@ -245,9 +253,6 @@ export const make: (
   const exportFibers = yield* FiberSet.make<void, never>()
   const runExportFork = yield* FiberSet.runtime(exportFibers)<never>()
 
-  const flusher = yield* Flusher
-  yield* flusher.register(runExport)
-
   yield* Scope.addFinalizer(
     scope,
     Effect.suspend(() => {
@@ -261,19 +266,38 @@ export const make: (
     )
   )
 
-  yield* Effect.sleep(exportInterval).pipe(
-    Effect.andThen(FiberSet.run(exportFibers, runExport)),
-    Effect.flatMap(Fiber.await),
-    Effect.forever,
-    Effect.forkIn(scope)
-  )
+  // `armed` is open while there is something to export. It changes in the
+  // same synchronous step as the buffer check, so a push is never stranded.
+  const armed = yield* Latch.make(exportsEmpty)
+  const wake = yield* Latch.make()
+  const disarmIfEmpty = Effect.sync(() => {
+    if (exportsEmpty || buffer.length > 0 || !armed.closeUnsafe()) return
+    wake.openUnsafe()
+  })
+  // Forked after the shutdown finalizer, so the loop stops before the shutdown flush.
+  yield* Effect.gen(function*() {
+    while (true) {
+      wake.closeUnsafe()
+      yield* armed.await
+      yield* Effect.race(Effect.sleep(exportInterval), wake.await)
+      yield* Fiber.await(yield* FiberSet.run(exportFibers, runExport))
+      yield* disarmIfEmpty
+    }
+  }).pipe(Effect.forkIn(scope))
+  const exportNow = Effect.andThen(runExport, disarmIfEmpty)
+
+  const flusher = yield* Flusher
+  yield* flusher.register(exportNow)
 
   return {
     push(data) {
-      if (disabledUntil !== undefined) return
+      // With no idle timer, the next push ends the disabled window.
+      if (isDisabled()) return
       buffer.push(data)
       if (options.maxBatchSize !== "disabled" && buffer.length >= options.maxBatchSize) {
-        runExportFork(runExport)
+        runExportFork(exportNow)
+      } else {
+        armed.openUnsafe()
       }
     }
   }

package/src/observability/OtlpSerialization.ts

@@ -9,6 +9,7 @@
  * @since 4.0.0
  */
 import * as Context from "../Context.ts"
+import * as Base64 from "../encoding/Base64.ts"
 import * as HttpBody from "../http/HttpBody.ts"
 import * as Layer from "../Layer.ts"
 import * as otlpProtobuf from "./internal/otlpProtobuf.ts"
@@ -30,13 +31,20 @@ 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
+// OTLP/JSON writes non-finite numbers as strings and bytes as base64.
+// The holder is read because Buffer#toJSON runs before the replacer.
+function jsonReplacer(this: Record<string, unknown>, key: string, value: unknown) {
+  if (typeof value === "number" && !Number.isFinite(value)) return String(value)
+  if (key === "bytesValue" && this[key] instanceof Uint8Array) return Base64.encode(this[key])
+  return 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")
+  return HttpBody.text(
+    json.includes("null") || json.includes("\"bytesValue\":") ? JSON.stringify(data, jsonReplacer) : json,
+    "application/json"
+  )
 }
 
 /**
@@ -45,7 +53,7 @@ const jsonBody = (data: unknown): HttpBody.HttpBody => {
  * **Details**
  *
  * `NaN`, `Infinity` and `-Infinity` are written as the strings OTLP/JSON
- * expects, not as `null`.
+ * expects, not as `null`. `bytesValue` data is written as a base64 string.
  *
  * @stability unstable
  * @category layers

package/src/observability/internal/otlpProtobuf.ts

@@ -368,14 +368,14 @@ export const encodeTracesData = (tracesData: TraceData): Uint8Array =>
  */
 export const encodeNumberDataPoint = (point: {
   readonly attributes: ReadonlyArray<KeyValue>
-  readonly startTimeUnixNano: string
+  readonly startTimeUnixNano?: string | undefined
   readonly timeUnixNano: string
   readonly asDouble?: number | undefined
   readonly asInt?: string | number | bigint | undefined
   readonly flags?: number | undefined
 }): Uint8Array =>
   Proto.concat(
-    Proto.fixed64Field(2, BigInt(point.startTimeUnixNano)),
+    Proto.optionalFixed64Field(2, point.startTimeUnixNano),
     Proto.fixed64Field(3, BigInt(point.timeUnixNano)),
     point.asDouble !== undefined
       ? Proto.doubleField(4, point.asDouble)
@@ -407,7 +407,7 @@ export const encodeNumberDataPoint = (point: {
  */
 export const encodeHistogramDataPoint = (point: {
   readonly attributes: ReadonlyArray<KeyValue>
-  readonly startTimeUnixNano: string
+  readonly startTimeUnixNano?: string | undefined
   readonly timeUnixNano: string
   readonly count: string | number | bigint
   readonly sum?: number | undefined
@@ -426,7 +426,7 @@ export const encodeHistogramDataPoint = (point: {
     ...point.explicitBounds.map((bound) => Proto.doubleField(7, bound))
   )
   return Proto.concat(
-    Proto.fixed64Field(2, BigInt(point.startTimeUnixNano)),
+    Proto.optionalFixed64Field(2, point.startTimeUnixNano),
     Proto.fixed64Field(3, BigInt(point.timeUnixNano)),
     Proto.fixed64Field(4, BigInt(point.count)),
     point.sum !== undefined ? Proto.doubleField(5, point.sum) : new Uint8Array(0),
@@ -515,7 +515,7 @@ export const encodeHistogram = (histogram: {
  */
 export const encodeSummaryDataPoint = (point: {
   readonly attributes: ReadonlyArray<KeyValue>
-  readonly startTimeUnixNano: string
+  readonly startTimeUnixNano?: string | undefined
   readonly timeUnixNano: string
   readonly count: string | number | bigint
   readonly sum: number
@@ -523,7 +523,7 @@ export const encodeSummaryDataPoint = (point: {
   readonly flags?: number | undefined
 }): Uint8Array =>
   Proto.concat(
-    Proto.fixed64Field(2, BigInt(point.startTimeUnixNano)),
+    Proto.optionalFixed64Field(2, point.startTimeUnixNano),
     Proto.fixed64Field(3, BigInt(point.timeUnixNano)),
     Proto.fixed64Field(4, BigInt(point.count)),
     Proto.doubleField(5, point.sum),

package/src/observability/internal/protobuf.ts

@@ -213,3 +213,13 @@ export const optionalStringField = (
   fieldNumber: number,
   value: string | undefined
 ): Uint8Array => value !== undefined && value !== "" ? stringField(fieldNumber, value) : new Uint8Array(0)
+
+/**
+ * Encodes a fixed64 field if the value is defined
+ *
+ * @internal
+ */
+export const optionalFixed64Field = (
+  fieldNumber: number,
+  value: string | undefined
+): Uint8Array => value !== undefined ? fixed64Field(fieldNumber, BigInt(value)) : new Uint8Array(0)