The divisor taking the runtime reserve off the ceiling. The GC and the RTS get a fifth of whatever the pod has.

The smallest runtime reserve, so a tiny pod still leaves the RTS something to breathe with.

The cache aggregate's share of the application heap, the ceiling less the runtime reserve. The computed shares sum to under 100%, so a plan with no floor and no pin in it fits by construction.

The publish aggregate's share of the application heap, and the computed request cap's.

The memory-queue depth's share of the application heap.

The mirror-artifact tenant's share of the application heap. It is the charged envelope, kept small so the background back-fill never crowds the serve hot path.

The metadata ingest ceiling, independent of the heap and CPU controls.

The smallest computed publish-body cap.

The largest computed publish-body cap.

The publish-body cap a pod with no heap-ceiling datapoint gets.

The floor keeps a pod that can afford one caching a useful working set. The shed ladder may still take the aggregate to zero.

The maximum computed aggregate for local metadata retention.

The cache aggregate a pod with no heap-ceiling datapoint gets.

Shared entry allowance (16 KiB), matching the present-selected base charge. Calibration and cardinality limits: PR #1469.

The smallest computed cache entry bound.

The largest computed cache entry bound.

The depth the queue tenant sheds to, and the floor under any computed depth.

The largest computed memory-queue depth.

The memory-queue depth a pod with no heap-ceiling datapoint gets.

With no ceiling datapoint the publish aggregate falls back to a few maximum requests' worth of concurrent body room.

The transient envelope one mirrored artifact holds, as a multiple of the buffered tarball B. The tarball, its base64 Text, and the publish document coexist at ~3.7x B, rounded up so the peak fits.

The ceiling the plan clamps the computed artifact cap to, and the no-ceiling fallback. The charged envelope is therefore at most this times mirrorArtifactEnvelopeMultiplier.

The bytes a memory-queue depth charges. Zero unless the memory backend runs.

The enqueue hand-off buffer, charged whatever the backend behind it.

Whether any mount mirrors, whatever backend carries the jobs. The enqueue buffer rides this.

Whether the in-memory queue runs, so its depth charges the heap.