effect 4.1.1 → 4.1.2

package/src/internal/jsonParser.ts

@@ -0,0 +1,307 @@
+const json5Space = /(?:[\t\n\v\f\r \u00A0\u2028\u2029\uFEFF\p{Zs}]|\/\/[^\n\r\u2028\u2029]*|\/\*[^]*?\*\/)*/uy
+const idStart = /[$_\p{ID_Start}]/u
+const idPart = /[$\u200C\u200D\p{ID_Continue}]/u
+const idName = /[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*/uy
+const hexDigits = /[\da-fA-F]*/y
+const isDigit = (code: number) => code >= 0x30 && code <= 0x39
+const isAsciiIdPart = (code: number) =>
+  (code >= 0x61 && code <= 0x7a) || (code >= 0x41 && code <= 0x5a) || isDigit(code) || code === 0x5f || code === 0x24
+
+const jsoncSpace = /(?:[ \t\r\n]|\/\/[^\r\n]*|\/\*[^]*?\*\/)*/uy
+const jsonNumber = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y
+
+// The escapes JSON and JSON5 share, indexed by the character after the backslash.
+// A null prototype keeps absent entries from resolving to inherited properties.
+const escapes: Record<number, string | undefined> = Object.create(null)
+for (const [escape, value] of ["\"\"", "\\\\", "//", "b\b", "f\f", "n\n", "r\r", "t\t"]) {
+  escapes[escape.charCodeAt(0)] = value
+}
+
+// Runs of string content that need no further inspection.
+const json5Double = /[^"\\\n\r]*/y
+const json5Single = /[^'\\\n\r]*/y
+// JSON forbids unescaped U+0000 through U+001F.
+// oxlint-disable-next-line no-control-regex
+const jsonDouble = /[^"\\\x00-\x1f]*/y
+
+type Format = "JSON5" | "JSONC"
+
+export const syntaxError = (text: string, at: number, format: Format): SyntaxError => {
+  const json5 = format === "JSON5"
+  const lines = text.slice(0, at).split(json5 ? /\r\n|[\n\r\u2028\u2029]/ : /\r\n|[\n\r]/)
+  return new SyntaxError(
+    `Invalid ${json5 ? "JSON5" : "JSONC"} at line ${lines.length}, column ${lines[lines.length - 1].length + 1}`
+  )
+}
+
+type Frame =
+  | { readonly object: true; readonly value: Record<string, unknown>; key: string; first: boolean }
+  | { readonly object: false; readonly value: Array<unknown>; first: boolean }
+
+const set = (object: Record<string, unknown>, key: string, value: unknown): void => {
+  // Members are own data properties, as with JSON.parse. Assignment creates one unless
+  // the key is inherited (`__proto__`, `constructor`, added accessors, ...), where it
+  // could run a setter or throw, so inherited keys are defined directly.
+  if (key in Object.prototype) {
+    Object.defineProperty(object, key, { value, writable: true, enumerable: true, configurable: true })
+  } else object[key] = value
+}
+
+// JSONC only uses the strict mode to locate errors after JSON.parse fails.
+export const parse = (text: string, format: Format): unknown => {
+  const json5 = format === "JSON5"
+  const space = json5 ? json5Space : jsoncSpace
+  // JSON strings forbid raw characters below U+0020; JSON5 strings only forbid line breaks.
+  const plainFloor = json5 ? 0 : 0x20
+  let i = 0
+
+  const fail = (at: number): never => {
+    throw syntaxError(text, at, format)
+  }
+
+  /** Skips whitespace and comments, rejecting a `/` that starts neither. */
+  const skip = () => {
+    // ASCII whitespace dominates formatted documents; the pattern handles the rest.
+    let code = text.charCodeAt(i)
+    while (code === 0x20 || code === 0x0a || code === 0x0d || code === 0x09) code = text.charCodeAt(++i)
+    if (code > 0x20 && code !== 0x2f && code < 0xa0) return
+    space.lastIndex = i
+    space.test(text)
+    i = space.lastIndex
+    if (text.charCodeAt(i) === 0x2f) {
+      fail(text.charAt(i + 1) === "*" ? text.length : i + 1)
+    }
+  }
+
+  /** Advances past a sticky pattern at `i`, returning the matched length. */
+  const run = (pattern: RegExp) => {
+    pattern.lastIndex = i
+    const length = pattern.test(text) ? pattern.lastIndex - i : 0
+    i += length
+    return length
+  }
+
+  const word = <A>(literal: string, result: A): A => {
+    if (!text.startsWith(literal, i)) {
+      let at = i
+      while (text.charAt(at) === literal[at - i]) at++
+      fail(at)
+    }
+    i += literal.length
+    return result
+  }
+
+  const hex = (count: number) => {
+    let value = 0
+    for (const end = i + count; i < end; i++) {
+      const code = text.charCodeAt(i)
+      const lower = code | 0x20
+      if (isDigit(code)) value = value * 16 + code - 0x30
+      else if (lower >= 0x61 && lower <= 0x66) value = value * 16 + lower - 0x57
+      else fail(i)
+    }
+    return String.fromCharCode(value)
+  }
+
+  const number = () => {
+    if (!json5) {
+      const start = i
+      if (run(jsonNumber) === 0) fail(i)
+      return Number(text.slice(start, i))
+    }
+    let code = text.charCodeAt(i)
+    let sign = 1
+    if (code === 0x2b || code === 0x2d) {
+      if (code === 0x2d) sign = -1
+      code = text.charCodeAt(++i)
+    }
+    const start = i
+    if (code === 0x49) return word("Infinity", sign * Infinity)
+    if (code === 0x4e) return word("NaN", NaN)
+    if (code === 0x30 && (text.charCodeAt(i + 1) | 0x20) === 0x78) {
+      i += 2
+      if (run(hexDigits) === 0) fail(i)
+      return sign * Number(text.slice(start, i))
+    }
+    // Integers below 2^53 are accumulated directly; anything else goes through Number.
+    let integer = 0
+    if (code === 0x30) code = text.charCodeAt(++i)
+    else if (isDigit(code)) {
+      do {
+        integer = integer * 10 + code - 0x30
+        code = text.charCodeAt(++i)
+      } while (isDigit(code))
+    } else if (code !== 0x2e) fail(i)
+    if (code !== 0x2e && code !== 0x65 && code !== 0x45 && i - start < 16) return sign * integer
+    if (code === 0x2e) {
+      const fraction = ++i
+      while (isDigit(text.charCodeAt(i))) i++
+      // A leading decimal point needs digits after it; a trailing one does not.
+      if (i === fraction && fraction === start + 1) fail(i)
+      code = text.charCodeAt(i)
+    }
+    if (code === 0x65 || code === 0x45) {
+      code = text.charCodeAt(++i)
+      if (code === 0x2b || code === 0x2d) i++
+      const exponent = i
+      while (isDigit(text.charCodeAt(i))) i++
+      if (i === exponent) fail(i)
+    }
+    return sign * Number(text.slice(start, i))
+  }
+
+  const string = (quote: number) => {
+    const plain = quote === 0x27 ? json5Single : json5 ? json5Double : jsonDouble
+    let result = ""
+    for (i++;;) {
+      // Plain content runs until the quote, an escape, a line break, a control character
+      // JSON forbids, or the end of input, where `code` is NaN and fails the last test.
+      const start = i
+      let code = text.charCodeAt(i)
+      // Short runs are cheaper to scan by hand; long runs are handed to the pattern.
+      const handoff = i + 24
+      while (code !== quote && code !== 0x5c && code !== 0x0a && code !== 0x0d && code >= plainFloor) {
+        if (++i === handoff) {
+          run(plain)
+          code = text.charCodeAt(i)
+          break
+        }
+        code = text.charCodeAt(i)
+      }
+      result += text.slice(start, i)
+      i++
+      if (code === quote) return result
+      // Anything else that stops a plain run is an escape or a forbidden character.
+      if (code !== 0x5c) fail(i - 1)
+      const escape = text.charCodeAt(i++)
+      const simple = escapes[escape]
+      if (simple !== undefined) result += simple
+      else if (escape === 0x75) result += hex(4)
+      else if (!json5 || i > text.length || (escape >= 0x31 && escape <= 0x39)) fail(i - 1)
+      else if (escape === 0x76) result += "\v"
+      else if (escape === 0x78) result += hex(2)
+      else if (escape === 0x30) {
+        if (isDigit(text.charCodeAt(i))) fail(i)
+        result += "\0"
+      } else if (escape === 0x0d) {
+        // A CR LF line continuation contributes nothing, like a single line terminator.
+        if (text.charCodeAt(i) === 0x0a) i++
+      } else if (escape !== 0x0a && escape !== 0x2028 && escape !== 0x2029) result += text[i - 1]
+    }
+  }
+
+  const identifier = () => {
+    const start = i
+    let code = text.charCodeAt(i)
+    if (isAsciiIdPart(code) && !isDigit(code)) {
+      do code = text.charCodeAt(++i)
+      while (isAsciiIdPart(code))
+      // Past an ASCII name, only an escape or a non-ASCII character can continue it.
+      if (code !== 0x5c && !(code >= 0x80)) return text.slice(start, i)
+      i = start
+    }
+    run(idName)
+    let name = text.slice(start, i)
+    if (name !== "" && text.charAt(i) !== "\\") return name
+    // Escapes are validated one code point at a time.
+    for (;;) {
+      const at = i
+      const valid = name === "" ? idStart : idPart
+      let c = String.fromCodePoint(text.codePointAt(i) ?? 0)
+      if (c === "\\") {
+        if (text.charAt(i + 1) !== "u") fail(i + 1)
+        i += 2
+        c = hex(4)
+        if (!valid.test(c)) fail(at)
+      } else if (i < text.length && valid.test(c)) i += c.length
+      else if (name === "") fail(i)
+      else return name
+      name += c
+    }
+  }
+
+  const stack: Array<Frame> = []
+
+  /**
+   * Reads a value at `i`, which must already be past any whitespace. Opening a
+   * collection returns `undefined`; the collection is completed later.
+   */
+  const value = (): unknown => {
+    const code = text.charCodeAt(i)
+    switch (code) {
+      case 0x7b:
+        stack.push({ object: true, value: {}, key: "", first: true })
+        i++
+        return undefined
+      case 0x5b:
+        stack.push({ object: false, value: [], first: true })
+        i++
+        return undefined
+      case 0x22:
+        return string(0x22)
+      case 0x27:
+        return json5 ? string(0x27) : fail(i)
+      case 0x6e:
+        return word("null", null)
+      case 0x74:
+        return word("true", true)
+      case 0x66:
+        return word("false", false)
+      case 0x2b:
+      case 0x2d:
+      case 0x2e:
+      case 0x49:
+      case 0x4e:
+        return number()
+    }
+    return isDigit(code) ? number() : fail(i)
+  }
+
+  /** After a member: consumes a comma unless the collection ends. */
+  const separated = (close: number) => {
+    skip()
+    const code = text.charCodeAt(i)
+    if (code === close) return
+    if (code !== 0x2c) fail(i)
+    i++
+    skip()
+    if (!json5 && text.charCodeAt(i) === close) fail(i)
+  }
+
+  skip()
+  let result = value()
+  // An explicit stack keeps deep nesting off the call stack.
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1]
+    const close = frame.object ? 0x7d : 0x5d
+    if (frame.first) skip()
+    else separated(close)
+    if (text.charCodeAt(i) === close) {
+      stack.pop()
+      i++
+      const parent = stack[stack.length - 1]
+      if (parent === undefined) result = frame.value
+      else if (parent.object) set(parent.value, parent.key, frame.value)
+      else parent.value.push(frame.value)
+      continue
+    }
+    frame.first = false
+    if (!frame.object) {
+      const item = value()
+      if (item !== undefined) frame.value.push(item)
+    } else {
+      const quote = text.charCodeAt(i)
+      if (!json5 && quote !== 0x22) fail(i)
+      const key = quote === 0x22 || quote === 0x27 ? string(quote) : identifier()
+      skip()
+      if (text.charCodeAt(i++) !== 0x3a) fail(i - 1)
+      skip()
+      const item = value()
+      if (item === undefined) frame.key = key
+      else set(frame.value, key, item)
+    }
+  }
+  skip()
+  if (i < text.length) fail(i)
+  return result
+}

package/src/internal/persistence.ts

@@ -1,13 +1,21 @@
 /** @internal */
 export const sqlCleanupBatchSize = 1000
 
+/**
+ * Percent-encodes `%` and `:` so the result contains no `:` and distinct inputs
+ * stay distinct.
+ *
+ * @internal
+ */
+export const escapeKeySegment = (segment: string): string => segment.replace(/%/g, "%25").replace(/:/g, "%3A")
+
 /**
  * Key prefix for a persistence store. The store id is escaped so the namespace
  * always ends at its first `:`, and distinct store / key pairs never collide.
  *
  * @internal
  */
-export const storeNamespace = (storeId: string): string => `${storeId.replace(/%/g, "%25").replace(/:/g, "%3A")}:`
+export const storeNamespace = (storeId: string): string => `${escapeKeySegment(storeId)}:`
 
 /** @internal */
 export const escapeRedisGlob = (pattern: string): string => pattern.replace(/[\\*?[\]]/g, "\\$&")

package/src/internal/sql.ts

@@ -1,4 +1,8 @@
+import { Clock } from "../Clock.ts"
 import * as Context from "../Context.ts"
+import type * as Fiber from "../Fiber.ts"
+import type * as Tracer from "../Tracer.ts"
+import { TracerTimingEnabled } from "./references.ts"
 
 /**
  * The transaction service of the innermost transaction started with
@@ -12,3 +16,24 @@ export const CurrentTransactionService = Context.Reference<Context.Key<any, obje
   "effect/sql/CurrentTransactionService",
   { defaultValue: () => undefined }
 )
+
+/**
+ * The clock to measure connection wait time with, or `undefined` without span
+ * timing, when the span has no start time to measure from.
+ *
+ * @internal
+ */
+export const waitClock = (fiber: Fiber.Fiber<unknown, unknown>): Clock | undefined =>
+  fiber.getRef(TracerTimingEnabled) ? fiber.getRef(Clock) : undefined
+
+/**
+ * Records the time from the span's start to the connection hand-off as
+ * `db.client.connection.wait_time_ms`.
+ *
+ * @internal
+ */
+export const recordConnectionWait = (span: Tracer.Span, clock: Clock): void =>
+  span.attribute(
+    "db.client.connection.wait_time_ms",
+    Number(clock.currentTimeNanosUnsafe() - span.status.startTime) / 1e6
+  )

package/src/internal/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = "4.1.1"
+export const version = "4.1.2"

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/persistence/RateLimiter.ts

@@ -16,6 +16,7 @@ import * as Context from "../Context.ts"
 import * as Duration from "../Duration.ts"
 import * as Effect from "../Effect.ts"
 import { flow, identity } from "../Function.ts"
+import { escapeKeySegment } from "../internal/persistence.ts"
 import * as Layer from "../Layer.ts"
 import * as Schedule from "../Schedule.ts"
 import * as Schema from "../Schema.ts"
@@ -996,6 +997,13 @@ export const layerStoreMemory: Layer.Layer<
  * Creates a Redis-backed `RateLimiterStore` using Lua scripts and the
  * configured key prefix.
  *
+ * **Details**
+ *
+ * State for a rate-limit key is stored under `<prefix><key>`, with
+ * `<prefix><key>:refill` holding token-bucket refill times and
+ * `<prefix><key>:adaptive` holding adaptive state. `%` and `:` in the key are
+ * percent-encoded so different keys never share Redis state.
+ *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
@@ -1007,6 +1015,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
 ) {
   const prefix = options?.prefix ?? "ratelimiter:"
   const redis = yield* Redis.Redis
+  const redisKey = (key: string) => `${prefix}${escapeKeySegment(key)}`
 
   const fixedWindow = redis.eval(fixedWindowScript)
   const tokenBucket = redis.eval(tokenBucketScript)
@@ -1015,7 +1024,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
 
   return RateLimiterStore.of({
     fixedWindow(options) {
-      const key = `${prefix}${options.key}`
+      const key = redisKey(options.key)
       const refillMillis = Duration.toMillis(options.refillRate)
       return Effect.mapError(
         Effect.map(
@@ -1032,7 +1041,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
       )
     },
     tokenBucket(options) {
-      const key = `${prefix}${options.key}`
+      const key = redisKey(options.key)
       const lastRefillKey = `${key}:refill`
       const refillMillis = Duration.toMillis(options.refillRate)
       return Effect.clockWith((clock) =>
@@ -1060,7 +1069,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
       )
     },
     adaptiveConsume(options) {
-      const key = `${prefix}${options.key}:adaptive`
+      const key = `${redisKey(options.key)}:adaptive`
       return Effect.map(
         Effect.mapError(
           adaptiveConsume(
@@ -1087,7 +1096,7 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
     adaptiveFeedback(options) {
       if (options.status !== 429 || options.retryAfter === undefined) return Effect.void
       const retryAfterMillis = clampAdaptiveDurationMillis(Duration.toMillis(options.retryAfter))
-      const key = `${prefix}${options.key}:adaptive`
+      const key = `${redisKey(options.key)}:adaptive`
       return Effect.asVoid(
         Effect.mapError(
           adaptiveFeedback(

package/src/rpc/RpcServer.ts

@@ -902,6 +902,17 @@ export const make: <Rpcs extends Rpc.Any>(
     request: RequestEncoded,
     payload: unknown
   ) => {
+    // the headers come from the wire unvalidated, and malformed input makes
+    // `Headers.fromInput` throw
+    let headers: Headers.Headers
+    try {
+      headers = Headers.fromInput(request.headers)
+    } catch {
+      const reason = "Invalid request headers"
+      return request.isNotification === true
+        ? dropNotification(reason)
+        : sendRequestDefect(client, requestId, schemas.encodeExit, reason)
+    }
     // nothing is encoded for a notification, and only a reply would remove its schemas
     if (request.isNotification !== true) {
       client.schemas.set(
@@ -919,7 +930,7 @@ export const make: <Rpcs extends Rpc.Any>(
     const decoded = request as Types.Mutable<RequestEncoded>
     decoded.id = requestId
     decoded.payload = payload
-    decoded.headers = Headers.fromInput(request.headers) as any
+    decoded.headers = headers as any
     return server.write(client.id, decoded as any)
   }