Why .flatMap() is so inefficient (non lazy)?

Question

After the first question about understanding deeply java streams spliterators here, another subtle question about streams: Why the implementation of .flatMap() in Java is so inefficient (non lazy)?

Typically the streams should be as much lazy as possible, but .flatMap() method is not.

For example:

stream.flatMap(this::getStreamWith10HeavyComputationElems).firstFirst() will consume 10 elements (10 heavy computations) before returning the first heavy computation result.

stream.flatMap(this::getStreamWith10HeavyComputationElems).limit(11).count() will consume 20 elements (2x10 heavy computations) before returning 11.

The question is why Java uses a non lazy implementation?

    @Test
    void flatMap_native() throws Exception {
        AtomicInteger count = new AtomicInteger();
        Stream<Long> stream = LongStream.range(0, 5).boxed()
                .flatMap(num -> LongStream.range(0, 10).boxed()
                                    .peek(x -> count.incrementAndGet()))
                .limit(11);

        assertThat(stream).hasSize(11);
        assertThat(count).hasValue(20); //!why? - should be 11!
    }

As workaround I created my own implementation of flatMap, but it lacks fluency in comparison with the native call: flatMap(stream, mapper) vs native stream.flatMap(mapper).

public static <T, R> Stream<R> flatMap(Stream<? extends T> stream, Function<? super T, ? extends Stream<? extends R>> mapper) {
    // Outside the class to be able to close it, starts with stream.empty
    AtomicReference<Stream<? extends R>> flatMapStreamRef = new AtomicReference<>(Stream.empty());

    // Defining a better spliterator than the native flatMap one.
    class FlatMapSpliterator implements Spliterator<R> {
        private final AtomicReference<T> item = new AtomicReference<>();
        private final Spliterator<? extends T> spliterator;
        private Stream<? extends R> flatMapStream = flatMapStreamRef.get();
        private Spliterator<? extends R> flatMapSpliterator = flatMapStream.spliterator();

        private FlatMapSpliterator(Spliterator<? extends T> spliterator) {
            this.spliterator = spliterator;
        }

        @Override
        public boolean tryAdvance(Consumer<? super R> action) {
            while(true) {
                if (flatMapSpliterator.tryAdvance(action)) {
                    return true;
                }
                if (!spliterator.tryAdvance(item::set)) {
                    return false; // nothing more to process
                }
                Stream<? extends R> stream = mapper.apply(item.get());
                if(stream != null) {
                    flatMapStream.close();
                    flatMapStream = stream;
                    flatMapStreamRef.set(stream);
                    flatMapSpliterator = flatMapStream.spliterator();
                }
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public Spliterator<R> trySplit() {
            Spliterator<? extends R> subFlatMapSpliterator = flatMapSpliterator.trySplit();
            if(subFlatMapSpliterator != null) {
                return (Spliterator<R>) subFlatMapSpliterator;
            }

            Spliterator<? extends T> subSpliterator = spliterator.trySplit();
            if(subSpliterator == null) {
                return null;
            }

            return new FlatMapSpliterator(subSpliterator);
        }

        @Override
        public long estimateSize() {
            // If both estimate size are Long.MAX_VALUE then math overflow will happen
            long estimateSize = spliterator.estimateSize() + flatMapSpliterator.estimateSize();
            return estimateSize < 0 ? Long.MAX_VALUE : estimateSize;
        }

        @Override
        public int characteristics() {
            // Maintain only ORDERED (used by native flatMap)
            return spliterator.characteristics() & ORDERED;
        }
    }

    return StreamSupport.stream(new FlatMapSpliterator(stream.spliterator()), stream.isParallel())
            .onClose(stream::close)
            .onClose(flatMapStreamRef.get()::close);
}