static final Function<@Nullable Throwable, ? extends T> nullTrailers = () -> null;

if (finalizer == nullTrailers) {
   // complete immediately. 
}

// T tail -> removed
Func<> finallizer
..

public onError() { // upstream error
    if (finalizer != null) {
        // If we use finalizer only, upstream error always replaced with finalizer.apply, can't close(cause);
        downstream.onNext(finalizer.apply(cause));
        close0(null); // downstream.onComplete() with finalizer
    } else {
        close0(cause); // downstream.onError() with tail
    }
}

    @Test
    void finalizer_return_null_upstream_thrown() {
        // given
        final StreamMessage<Integer> streamMessage = StreamMessage.of(2, 3, 4, 5);
        final StreamMessage<Integer> aborted = streamMessage
                .peek(val -> {
                    if (val == 5) {
                        throw new RuntimeException();
                    }
                });
        final Function<Throwable, Integer> finalizer = unused -> null;
        final StreamMessage<Integer> publisher = new SurroundingPublisher<>(1, aborted, finalizer);

        // when & then
        StepVerifier.create(publisher)
                    .expectNext(1, 2, 3, 4)
                    .expectError(RuntimeException.class) // 👈 👈 upstreamException is propagated when finalizer return null
                    .verify();
    }