Before attempting to fix I want to make sure I understand the problem. I reproduced it with the following code:

from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.quantum_info import SparsePauliOp
from qiskit_aer.primitives import EstimatorV2
from qiskit_ibm_runtime.fake_provider import FakeWashingtonV2

N = 12
qc = QuantumCircuit(N)

qc.x(range(N))
qc.h(range(N))

for kk in range(N // 2, 0, -1):
    qc.ch(kk, kk - 1)
for kk in range(N // 2, N - 1):
    qc.ch(kk, kk + 1)

op = SparsePauliOp('Z'*12)
pm = generate_preset_pass_manager(backend=FakeWashingtonV2(), optimization_level=1)
isa_circuit = pm.run(qc)
mapped_observable = op.apply_layout(isa_circuit.layout)

est = EstimatorV2()
res = est.run(pubs=[(isa_circuit, mapped_observable)]).result()
print(res)

If I understand correctly, the current solution for transpiling against large backends is present only in Estimator (not in EstimatorV2) and is simply copying the number of qubits from the circuit prior to its transpilation.

This is irrelevant for a use case as in the example above, where the circuit is transpiled and only afterwards sent to the simulator (with its qubit number now listed as 127).

@nonhermitian, am I getting this right? In this case Aer has to actively go over the circuit and count the number of qubits used in practice, correct?

The root issue is that the number of qubits that needs to be simulated is the number of active qubits in the circuit. As in the example here, this need not equal the total number of device in a transpiled circuit. The Aer backend.run interface will perform this truncation, so the primitives should as well.