When optimizing performance, avoid whole-object work and unbounded resource growth. Apply these standards:

1) Targeted extraction/rewrites (no full parsing)

• If you only need one JSON field, read it with gjson/sonic.Get and rewrite with sjson, rather than unmarshalling the full body/request.
• Guard on JSON shape before using sjson.Set to avoid corrupting non-JSON/multipart bodies.

Example (safe “model” rewrite):

func rewriteTopLevelModel(body []byte, alias, modelID string) []byte {
  trimmed := bytes.TrimLeft(body, " \t\r\n")
  if len(trimmed) == 0 || trimmed[0] != '{' { // multipart/form-data etc.
    return body
  }
  cur := gjson.GetBytes(body, "model")
  if cur.Type != gjson.String || !strings.EqualFold(cur.Str, alias) {
    return body
  }
  out, err := sjson.SetBytes(body, "model", modelID)
  if err != nil { return body }
  return out
}

2) Bound buffering and “perpetual due” logic

• Any paused replay buffer, retry loop, or time-based scheduler must have hard limits (e.g., max bytes) and fail-closed handling for invalid/negative durations.

3) Coalesce duplicate concurrent work

• For expensive refresh/exchange operations, use singleflight (or equivalent) so only one goroutine performs the work per key while others wait.

4) Pooling hygiene (prevent allocation retention)

• If you use pooled objects, clear embedded request/state that retains large allocations before returning to the pool (do in-place zeroing; don’t rely on GC).

These practices together reduce CPU spent on unnecessary parsing/scanning, prevent memory blowups, and eliminate wasted concurrent work—directly improving throughput and latency.