impl Cache {
    fn get_hot(&self, ticket: &Ticket, count_miss: bool) -> Option<Hit> {
        let mut store = self.store.lock().unwrap_or_else(|e| e.into_inner());
        let expired = store.sweep();
        self.counters
            .expired
            .fetch_add(expired as u64, Ordering::Relaxed);
        if store.revision != ticket.revision
            || store.generation != ticket.generation
            || store
                .scope_generations
                .get(&ticket.scope)
                .copied()
                .unwrap_or(0)
                != ticket.scope_generation
            || store
                .key_generations
                .get(&ticket.key)
                .copied()
                .unwrap_or(0)
                != ticket.key_generation
        {
            return None;
        }
        if let Some(storage_key) = matching_hot_key(&store, ticket) {
            let Some(mut entry) = store.remove(&storage_key) else {
                return None;
            };
            if self.hot_entry_banned(&storage_key, &entry) {
                if count_miss {
                    self.counters.misses.fetch_add(1, Ordering::Relaxed);
                }
                drop(store);
                release_allocator_memory();
                return None;
            }
            let resident_age_seconds = hot_resident_age(&entry).as_secs();
            let age = entry
                .initial_age
                .saturating_add(entry.received.elapsed())
                .as_secs();
            let state = cache_state(
                age,
                entry.ttl,
                entry.stale_while_revalidate,
                entry.must_revalidate,
                entry.proxy_revalidate,
                entry.requires_revalidation,
                &ticket.request_headers,
            );
            if state.servable() {
                entry.hits = entry.hits.saturating_add(1);
                entry.last_access = Instant::now();
                entry.sequence = store.next_sequence();
                let mut response = Response::new(Body::from(entry.body.clone()));
                *response.headers_mut() = entry.headers.clone();
                if entry.transformed {
                    response
                        .extensions_mut()
                        .insert(crate::transform::CachedTransformed);
                }
                if entry.skip_compression {
                    response.extensions_mut().insert(crate::compression::Skip);
                }
                response.headers_mut().insert(
                    "age",
                    HeaderValue::from_str(&age.to_string()).expect("integer header"),
                );
                let result = Hit {
                    response,
                    body: entry.body.clone(),
                    hits: entry.hits,
                    transformed: entry.transformed,
                    remaining_ttl: entry.ttl.saturating_sub(age),
                    resident_age_seconds,
                    stale: state.stale(),
                    background_revalidate: state.background_revalidate(),
                };
                if let Some(c) = store.domain(&entry.scope, &entry.domain) {
                    c.saved_body_bytes = c.saved_body_bytes.saturating_add(entry.body.len() as u64);
                }
                store.bytes = store.bytes.saturating_add(entry.cost);
                store.logical_bytes = store.logical_bytes.saturating_add(entry.body.len());
                store.lru.insert(entry.sequence, storage_key);
                store.index_variant(entry.base_key, storage_key);
                store.entries.insert(storage_key, entry);
                self.counters.hits.fetch_add(1, Ordering::Relaxed);
                return Some(result);
            }
            store.bytes = store.bytes.saturating_add(entry.cost);
            store.logical_bytes = store.logical_bytes.saturating_add(entry.body.len());
            store.lru.insert(entry.sequence, storage_key);
            store.index_variant(entry.base_key, storage_key);
            store.entries.insert(storage_key, entry);
        }
        if count_miss {
            self.counters.misses.fetch_add(1, Ordering::Relaxed);
        }
        None
    }
    pub fn get(&self, ticket: &Ticket) -> Option<Hit> {
        self.get_hot(ticket, true)
    }
    async fn get_cold(&self, ticket: &Ticket, settings: &Settings) -> Option<Hit> {
        if !self.ticket_current(ticket) {
            return None;
        }
        let banned = {
            let mut cold = self.cold.lock().unwrap_or_else(|e| e.into_inner());
            matching_cold_key(&cold, ticket).and_then(|storage_key| {
                let banned = cold
                    .entries
                    .get(&storage_key)
                    .is_some_and(|entry| self.cold_entry_banned(&storage_key, entry));
                banned.then(|| cold.remove(&storage_key)).flatten()
            })
        };
        if let Some(entry) = banned {
            self.delete_cold_entry(entry);
            return None;
        }
        let (storage_key, entry) = {
            let mut cold = self.cold.lock().unwrap_or_else(|e| e.into_inner());
            let storage_key = matching_cold_key(&cold, ticket)?;
            let old_sequence = {
                let entry = cold.entries.get(&storage_key)?;
                if entry.revision != ticket.revision || entry.scope != ticket.scope {
                    return None;
                }
                let state = cache_state(
                    cold_age(entry),
                    entry.ttl,
                    entry.stale_while_revalidate,
                    entry.must_revalidate,
                    entry.proxy_revalidate,
                    entry.requires_revalidation,
                    &ticket.request_headers,
                );
                if !state.servable() {
                    return None;
                }
                entry.sequence
            };
            let sequence = cold.next_sequence();
            cold.lru.remove(&old_sequence);
            cold.lru.insert(sequence, storage_key);
            let entry = cold.entries.get_mut(&storage_key)?;
            entry.sequence = sequence;
            entry.last_access = SystemTime::now();
            entry.pinned_reads = entry.pinned_reads.saturating_add(1);
            (storage_key, entry.clone())
        };
        let _pin = ColdReadGuard {
            cache: self,
            key: storage_key,
            generation: entry.generation,
        };
        if entry.body_bytes > settings.max_object_bytes {
            self.counters
                .memory_pressure_rejections
                .fetch_add(1, Ordering::Relaxed);
            return None;
        }
        let Some(_read_lease) = self.try_reserve_transient(entry.body_bytes, settings) else {
            return None;
        };
        let _cold_read = ByteGaugeGuard::new(&self.cold_read_bytes_active, entry.body_bytes as u64);
        let body_vec = match tokio::fs::read(&entry.body_path).await {
            Ok(body) if cold_body_matches(&entry, &body) => body,
            _ => {
                self.counters.cold_errors.fetch_add(1, Ordering::Relaxed);
                if let Some(entry) = self.take_cold(&storage_key) {
                    self.delete_cold_entry(entry);
                }
                return None;
            }
        };
        let body_allocated = body_vec.capacity().max(body_vec.len());
        let extra = body_allocated.saturating_sub(entry.body_bytes);
        let extra_lease = if extra > 0 {
            self.try_reserve_transient(extra, settings)
        } else {
            None
        };
        if extra > 0 && extra_lease.is_none() {
            return None;
        }
        let _cold_read_extra = extra_lease
            .as_ref()
            .map(|_| ByteGaugeGuard::new(&self.cold_read_bytes_active, extra as u64));
        let body = Bytes::from(body_vec);
        if !self.ticket_current(ticket) {
            return None;
        }
        let age = cold_age(&entry);
        let state = cache_state(
            age,
            entry.ttl,
            entry.stale_while_revalidate,
            entry.must_revalidate,
            entry.proxy_revalidate,
            entry.requires_revalidation,
            &ticket.request_headers,
        );
        if !state.servable() {
            return None;
        }
        let hits = entry.hits.saturating_add(1);
        let cost = hot_entry_cost(
            body_allocated,
            &entry.headers,
            &entry.vary,
            &entry.scope,
            &entry.scheme,
            &entry.authority,
            &entry.domain,
            &entry.path,
            &entry.target,
            &entry.tags,
            entry.origin_etag.as_ref(),
            entry.origin_last_modified.as_ref(),
        );
        let resident_age_seconds = cold_resident_age(&entry);
        let hot_entry = Entry {
            base_key: entry.base_key,
            vary: entry.vary.clone(),
            scope: entry.scope.clone(),
            scheme: entry.scheme.clone(),
            authority: entry.authority.clone(),
            domain: entry.domain.clone(),
            path: entry.path.clone(),
            target: entry.target.clone(),
            tags: entry.tags.clone(),
            created_at: entry.created_at,
            headers: entry.headers.clone(),
            body: body.clone(),
            body_allocated,
            received: Instant::now(),
            last_access: Instant::now(),
            resident_since: Instant::now(),
            resident_age_base: Duration::from_secs(resident_age_seconds),
            initial_age: Duration::from_secs(age),
            ttl: entry.ttl,
            stale_while_revalidate: entry.stale_while_revalidate,
            stale_if_error: entry.stale_if_error,
            must_revalidate: entry.must_revalidate,
            proxy_revalidate: entry.proxy_revalidate,
            origin_etag: entry.origin_etag.clone(),
            origin_last_modified: entry.origin_last_modified.clone(),
            cost,
            sequence: 0,
            hits,
            transformed: entry.transformed,
            skip_compression: entry.skip_compression,
            requires_revalidation: entry.requires_revalidation,
        };
        if !self.insert_inner(ticket.clone(), hot_entry, settings, false) {
            return None;
        }
        let mut response = Response::new(Body::from(body.clone()));
        *response.headers_mut() = entry.headers;
        if entry.transformed {
            response
                .extensions_mut()
                .insert(crate::transform::CachedTransformed);
        }
        if entry.skip_compression {
            response.extensions_mut().insert(crate::compression::Skip);
        }
        response.headers_mut().insert(
            "age",
            HeaderValue::from_str(&age.to_string()).expect("integer header"),
        );
        {
            let mut store = self.store.lock().unwrap_or_else(|e| e.into_inner());
            if let Some(c) = store.domain(&ticket.scope, &ticket.domain) {
                c.saved_body_bytes = c.saved_body_bytes.saturating_add(entry.body_bytes as u64);
            }
        }
        self.counters.hits.fetch_add(1, Ordering::Relaxed);
        self.counters.cold_hits.fetch_add(1, Ordering::Relaxed);
        self.counters
            .cold_promotions
            .fetch_add(1, Ordering::Relaxed);
        Some(Hit {
            response,
            body,
            hits,
            transformed: entry.transformed,
            remaining_ttl: entry.ttl.saturating_sub(age),
            resident_age_seconds,
            stale: state.stale(),
            background_revalidate: state.background_revalidate(),
        })
    }
    pub async fn get_tiered(&self, ticket: &Ticket, settings: &Settings) -> Option<Hit> {
        if let Some(hit) = self.get_hot(ticket, false) {
            return Some(hit);
        }
        if let Some(hit) = self.get_cold(ticket, settings).await {
            return Some(hit);
        }
        self.counters.misses.fetch_add(1, Ordering::Relaxed);
        None
    }
    pub fn publish_revalidated(
        &self,
        ticket: Ticket,
        cached: &Revalidation,
        mut headers: HeaderMap,
        validation_headers: &HeaderMap,
        settings: &Settings,
        response_delay: Duration,
    ) -> Option<Hit> {
        let plan = plan(StatusCode::OK, &headers, settings, response_delay)?;
        if cached.body.len() > settings.max_object_bytes {
            return None;
        }
        if !headers.contains_key("date") {
            if let Ok(value) = httpdate::fmt_http_date(SystemTime::now()).parse() {
                headers.insert("date", value);
            }
        }
        for name in [
            "x-request-id",
            "x-cache",
            "x-cache-hits",
            "x-cache-status",
            "x-cache-reason",
            "cache-status",
        ] {
            headers.remove(name);
        }
        let hits = cached.hits.saturating_add(1);
        let age = plan.initial_age.as_secs();
        let remaining_ttl = plan.ttl.saturating_sub(age);
        let vary = plan.vary.clone();
        let tags = cache_tags(&headers);
        let origin_etag = validation_headers
            .get("etag")
            .cloned()
            .or_else(|| cached.origin_etag.clone());
        let origin_last_modified = validation_headers
            .get("last-modified")
            .cloned()
            .or_else(|| cached.origin_last_modified.clone());
        let cost = hot_entry_cost(
            cached.body_allocated,
            &headers,
            &vary,
            &ticket.scope,
            &ticket.scheme,
            &ticket.authority,
            &ticket.domain,
            &ticket.path,
            &ticket.target,
            &tags,
            origin_etag.as_ref(),
            origin_last_modified.as_ref(),
        );
        let storage_key = variant_key(&ticket.key, &vary, &ticket.request_headers);
        let resident_age = cached.resident_age_at_lookup.saturating_add(response_delay);
        let entry = Entry {
            base_key: ticket.key,
            vary,
            scope: ticket.scope.clone(),
            scheme: ticket.scheme.clone(),
            authority: ticket.authority.clone(),
            domain: ticket.domain.clone(),
            path: ticket.path.clone(),
            target: ticket.target.clone(),
            tags,
            created_at: ticket.created_at,
            headers: headers.clone(),
            body: cached.body.clone(),
            body_allocated: cached.body_allocated,
            received: plan.received,
            last_access: Instant::now(),
            resident_since: Instant::now(),
            resident_age_base: resident_age,
            initial_age: plan.initial_age,
            ttl: plan.ttl,
            stale_while_revalidate: plan.stale_while_revalidate,
            stale_if_error: plan.stale_if_error,
            must_revalidate: plan.must_revalidate,
            proxy_revalidate: plan.proxy_revalidate,
            origin_etag,
            origin_last_modified,
            cost,
            sequence: 0,
            hits,
            transformed: cached.transformed,
            skip_compression: cached.skip_compression,
            requires_revalidation: plan.requires_revalidation,
        };
        if !self.insert(ticket, entry, settings) {
            return None;
        }
        if cached.storage_key != storage_key {
            self.discard_storage_key(&cached.storage_key);
        }
        self.counters.hits.fetch_add(1, Ordering::Relaxed);
        let mut response = cached.response(headers);
        response.headers_mut().insert(
            "age",
            HeaderValue::from_str(&age.to_string()).expect("integer header"),
        );
        Some(Hit {
            response,
            body: cached.body.clone(),
            hits,
            transformed: cached.transformed,
            remaining_ttl,
            resident_age_seconds: resident_age.as_secs(),
            stale: false,
            background_revalidate: false,
        })
    }

    pub fn wrap(
        self: &Arc<Self>,
        response: Response,
        ticket: Ticket,
        plan: Plan,
        settings: &Settings,
    ) -> Response {
        self.wrap_with_fill(response, ticket, plan, settings, None)
    }

    pub fn wrap_with_fill(
        self: &Arc<Self>,
        response: Response,
        ticket: Ticket,
        plan: Plan,
        settings: &Settings,
        fill_leader: Option<FillLeaderGuard>,
    ) -> Response {
        let fill_size = plan.expected_length.unwrap_or(settings.max_object_bytes);
        let permits = if fill_size > 64 * 1024 * 1024 {
            FILL_SLOTS as u32
        } else if fill_size > 16 * 1024 * 1024 {
            4
        } else if fill_size > 4 * 1024 * 1024 {
            2
        } else {
            1
        };
        let permit = self.fills.clone().try_acquire_many_owned(permits);
        let Ok(permit) = permit else {
            self.counters.rejected_fills.fetch_add(1, Ordering::Relaxed);
            return response;
        };
        let (parts, body) = response.into_parts();
        let headers = parts.headers.clone();
        let origin_validators = parts
            .extensions
            .get::<crate::transform::OriginValidators>()
            .cloned();
        let origin_etag = match origin_validators.as_ref() {
            Some(validators) => validators.etag.clone(),
            None => headers.get("etag").cloned(),
        };
        let origin_last_modified = match origin_validators.as_ref() {
            Some(validators) => validators.last_modified.clone(),
            None => headers.get("last-modified").cloned(),
        };
        let initial_capacity = fill_size.min(64 * 1024);
        let Some(mut fill_gauge) = FillGauge::new(self.clone(), initial_capacity, settings) else {
            self.counters.rejected_fills.fetch_add(1, Ordering::Relaxed);
            self.record_reason(&ticket.scope, &ticket.domain, "hot_memory_pressure");
            return Response::from_parts(parts, body);
        };
        let data = Vec::with_capacity(initial_capacity);
        let actual_capacity = data.capacity();
        if actual_capacity > initial_capacity
            && !fill_gauge.grow(actual_capacity - initial_capacity, settings)
        {
            self.counters.rejected_fills.fetch_add(1, Ordering::Relaxed);
            self.record_reason(&ticket.scope, &ticket.domain, "fill_allocator_overshoot");
            return Response::from_parts(parts, body);
        }
        let candidate = Candidate {
            cache: self.clone(),
            ticket,
            plan,
            headers,
            data,
            fill_gauge,
            settings: settings.clone(),
            skip_compression: parts.extensions.get::<crate::compression::Skip>().is_some(),
            origin_etag,
            origin_last_modified,
            transformed: parts.extensions.get::<crate::transform::Applied>().is_some(),
            _permit: permit,
            _fill_leader: fill_leader,
        };
        Response::from_parts(
            parts,
            Body::new(FillBody {
                inner: body,
                candidate: Some(candidate),
                done: false,
            }),
        )
    }
    fn insert(&self, ticket: Ticket, entry: Entry, settings: &Settings) -> bool {
        self.insert_inner(ticket, entry, settings, true)
    }
    fn insert_inner(
        &self,
        ticket: Ticket,
        mut entry: Entry,
        settings: &Settings,
        count_stored: bool,
    ) -> bool {
        entry.base_key = ticket.key;
        let storage_key = variant_key(&ticket.key, &entry.vary, &ticket.request_headers);
        let vary_schema = entry.vary.clone();
        if self.entry_banned_before_insert(&storage_key, &entry) {
            self.counters.ban_matches.fetch_add(1, Ordering::Relaxed);
            return false;
        }
        if entry.cost > settings.max_bytes
            || (!entry.requires_revalidation
                && entry.initial_age.saturating_add(entry.received.elapsed()).as_secs()
                    >= retention_deadline(
                        entry.ttl,
                        entry.stale_while_revalidate,
                        entry.stale_if_error,
                        entry.origin_etag.is_some() || entry.origin_last_modified.is_some(),
                    ))
        {
            return false;
        }
        let mut store = self.store.lock().unwrap_or_else(|e| e.into_inner());
        if store.revision != ticket.revision
            || store.generation != ticket.generation
            || store
                .scope_generations
                .get(&ticket.scope)
                .copied()
                .unwrap_or(0)
                != ticket.scope_generation
            || store
                .key_generations
                .get(&ticket.key)
                .copied()
                .unwrap_or(0)
                != ticket.key_generation
        {
            return false;
        }
        // Do not keep objects for incompatible Vary schemas under the same
        // Varnish-style host+URL hash. A newer representation policy replaces
        // the older schema while preserving sibling values of the same Vary set.
        for key in incompatible_hot_variants(&store, &ticket.key, &vary_schema) {
            store.remove(&key);
        }
        store.remove(&storage_key);
        self.counters
            .expired
            .fetch_add(store.sweep() as u64, Ordering::Relaxed);
        let revision = store.revision;
        let generation = store.generation;
        let mut released_hot = false;
        let mut removed = 0usize;
        while store.entries.len() >= settings.max_entries
            || store.bytes.saturating_add(entry.cost) > settings.max_bytes
        {
            if removed >= settings.hot_eviction_max_objects {
                self.counters
                    .hot_eviction_limited
                    .fetch_add(1, Ordering::Relaxed);
                break;
            }
            let Some((_, key)) = store.lru.first_key_value().map(|(seq, key)| (*seq, *key)) else {
                break;
            };
            if let Some(old) = store.remove(&key) {
                removed = removed.saturating_add(1);
                released_hot = true;
                let scope_generation = store
                    .scope_generations
                    .get(&old.scope)
                    .copied()
                    .unwrap_or(0);
                let key_generation = store.key_generations.get(&old.base_key).copied().unwrap_or(0);
                if !(settings.cold_enabled
                    && settings.cold_on_lru
                    && self.enqueue_demotion(key, old, revision, generation, scope_generation, key_generation))
                {
                    self.counters.evictions.fetch_add(1, Ordering::Relaxed);
                }
            }
        }
        if store.entries.len() >= settings.max_entries
            || store.bytes.saturating_add(entry.cost) > settings.max_bytes
        {
            self.counters
                .memory_pressure_rejections
                .fetch_add(1, Ordering::Relaxed);
            drop(store);
            if released_hot {
                release_allocator_memory();
            }
            return false;
        }
        if count_stored {
            if let Some(c) = store.domain(&entry.scope, &entry.domain) {
                c.stored += 1;
            }
        }
        entry.last_access = Instant::now();
        entry.sequence = store.next_sequence();
        store.bytes = store.bytes.saturating_add(entry.cost);
        store.logical_bytes = store.logical_bytes.saturating_add(entry.body.len());
        store.lru.insert(entry.sequence, storage_key);
        store.index_variant(entry.base_key, storage_key);
        store.entries.insert(storage_key, entry);
        drop(store);
        if released_hot {
            release_allocator_memory();
        }
        let mut cold_delete = Vec::new();
        {
            let mut cold = self.cold.lock().unwrap_or_else(|e| e.into_inner());
            for key in incompatible_cold_variants(&cold, &ticket.key, &vary_schema) {
                if let Some(old) = cold.remove(&key) {
                    cold_delete.push(old);
                }
            }
            if let Some(old) = cold.remove(&storage_key) {
                cold_delete.push(old);
            }
        }
        for old in cold_delete {
            self.delete_cold_entry(old);
        }
        if count_stored {
            self.counters.stored.fetch_add(1, Ordering::Relaxed);
        }
        true
    }
}