The capacity pool a store's requests debit, which several stores can share.

Build a scope, folding case and surrounding space so two spellings of one pool are one pool.

The scope as an audit line names it.

One pool a backend meters its callers by. The arms are pool shapes rather than one vendor's API names, so each backend maps its own calls onto them.

Read a configured dimension, refusing a spelling this build meters nothing under.

Where a scope's quota numbers came from, which the boot line reports.

One store's capacity: the pool it shares, its per-second quotas, and what each request costs.

A store whose backend publishes no capacity and whose operator declared none. Its cycles are paced by the sweep's own pauses alone.

Whether anything bounds this store's request rate.

Combine two descriptions of one pool: the tightest quota per dimension and the dearest cost per request kind, so two stores sharing a pool are paced by the narrower of what each claims.

The tightest quota in the pool, which the default budget fraction is derived from.

The resolved capacity as the boot line records it, naming where each number came from.

Every dimension's rate as a boot or audit line spells them, in dimension order. An empty map renders as the empty string, so a caller with a "none" to say says it itself.

A rational as a line spells it, rounded to whole hundredths. A budget fraction and a rate are both reported this way, so a line never carries an unbounded expansion.

One request a cycle makes against the store being dredged.

Every request a cycle can make, held to requestKindName the way quotaDimensions is.

Read a configured request kind, refusing a spelling no cycle makes.

What one cycle attempted, counted per request kind.

The tally of a single attempt.

Every kind the tally counted, beside its count.

The counts as an audit line reads them.

What one request of each kind costs its scope in seconds, at the rate a cycle runs.

Build a pace from the seconds each kind is held to.

The gate one store's requests pass through: it counts each one and waits its scope's pace.

What one cycle cost: each scope's own attempts, and the time it spent outside budget waits.

The cycle's own end of the budget: it opens a measurement, reads what the cycle cost, and installs the rate the next cycle's requests wait at.

One meter shared by every store a cycle touches, beside the gate each scope's requests pass through. The wait is injected, so a spec reads the pacing without serving it.