add CI

.github/workflows/get-example-changed.yml

@@ -24,7 +24,7 @@ jobs:
           fetch-depth: 0
       - name: Get example files that changed
         id: changed-files
-        uses: tj-actions/changed-files@v47
+        uses: tj-actions/changed-files@v46
         with:
           files: |
             examples/**

.github/workflows/get-leptos-changed.yml

@@ -18,7 +18,7 @@ jobs:
           fetch-depth: 0
       - name: Get source files that changed
         id: changed-source
-        uses: tj-actions/changed-files@v47
+        uses: tj-actions/changed-files@v46
         with:
           files_ignore: |
             .*/**/*

.github/workflows/run-cargo-make-task.yml

@@ -88,7 +88,7 @@ jobs:
         run: trunk --version
       - name: Install Node.js
         if: contains(inputs.directory, 'examples')
-        uses: actions/setup-node@v5
+        uses: actions/setup-node@v4
         with:
           node-version: 20
       - uses: pnpm/action-setup@v4

README.md

@@ -95,7 +95,7 @@ Here are some resources for learning more about Leptos:
 [`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use `cargo-leptos` and our starter templates for [Actix](https://github.com/leptos-rs/start) or [Axum](https://github.com/leptos-rs/start-axum).
 
 ```bash
-cargo install cargo-leptos --locked
+cargo install cargo-leptos
 cargo leptos new --git https://github.com/leptos-rs/start-axum
 cd [your project name]
 cargo leptos watch

tachys/src/ssr/mod.rs

@@ -378,91 +378,83 @@ impl Stream for StreamBuilder {
             let next_chunk = this.chunks.pop_front();
             match next_chunk {
                 None => {
-                    if this.pending_ooo.is_empty() {
-                        if this.sync_buf.is_empty() {
-                            Poll::Ready(None)
-                        } else {
-                            Poll::Ready(Some(mem::take(&mut this.sync_buf)))
-                        }
-                    } else {
-                        // check if *any* pending out-of-order chunk is ready
-                        for mut chunk in mem::take(&mut this.pending_ooo) {
-                            match chunk.as_mut().poll(cx) {
-                                Poll::Ready(OooChunk {
-                                    id,
-                                    chunks,
-                                    replace,
-                                    nonce,
-                                }) => {
-                                    let opening = format!("<!--s-{id}o-->");
-                                    let placeholder_at =
-                                        this.sync_buf.find(&opening);
-                                    if let Some(start) = placeholder_at {
-                                        let closing = format!("<!--s-{id}c-->");
-                                        let end = this
-                                            .sync_buf
-                                            .find(&closing)
-                                            .unwrap();
-                                        let chunks_iter =
-                                            chunks.into_iter().rev();
+                    // now, handle out-of-order chunks
+                    if let Some(mut pending) = this.pending_ooo.pop_front() {
+                        match pending.as_mut().poll(cx) {
+                            Poll::Ready(OooChunk {
+                                id,
+                                chunks,
+                                replace,
+                                nonce,
+                            }) => {
+                                let opening = format!("<!--s-{id}o-->");
+                                let placeholder_at =
+                                    this.sync_buf.find(&opening);
+                                if let Some(start) = placeholder_at {
+                                    let closing = format!("<!--s-{id}c-->");
+                                    let end =
+                                        this.sync_buf.find(&closing).unwrap();
+                                    let chunks_iter = chunks.into_iter().rev();
 
-                                        // TODO can probably make this more efficient
-                                        let (before, replaced) =
-                                            this.sync_buf.split_at(start);
-                                        let (_, after) = replaced.split_at(
-                                            end - start + closing.len(),
-                                        );
-                                        let mut buf = String::new();
-                                        buf.push_str(before);
+                                    // TODO can probably make this more efficient
+                                    let (before, replaced) =
+                                        this.sync_buf.split_at(start);
+                                    let (_, after) = replaced
+                                        .split_at(end - start + closing.len());
+                                    let mut buf = String::new();
+                                    buf.push_str(before);
 
-                                        let mut held_chunks = VecDeque::new();
-                                        for chunk in chunks_iter {
-                                            if let StreamChunk::Sync(ready) =
-                                                chunk
-                                            {
-                                                buf.push_str(&ready);
-                                            } else {
-                                                held_chunks.push_front(chunk);
-                                            }
+                                    let mut held_chunks = VecDeque::new();
+                                    for chunk in chunks_iter {
+                                        if let StreamChunk::Sync(ready) = chunk
+                                        {
+                                            buf.push_str(&ready);
+                                        } else {
+                                            held_chunks.push_front(chunk);
                                         }
-                                        buf.push_str(after);
-                                        this.sync_buf = buf;
-                                        for chunk in held_chunks {
+                                    }
+                                    buf.push_str(after);
+                                    this.sync_buf = buf;
+                                    for chunk in held_chunks {
+                                        this.chunks.push_front(chunk);
+                                    }
+                                } else {
+                                    OooChunk::push_start(
+                                        &id,
+                                        &mut this.sync_buf,
+                                    );
+                                    for chunk in chunks.into_iter().rev() {
+                                        if let StreamChunk::Sync(ready) = chunk
+                                        {
+                                            this.sync_buf.push_str(&ready);
+                                        } else {
                                             this.chunks.push_front(chunk);
                                         }
-                                    } else {
-                                        OooChunk::push_start(
-                                            &id,
-                                            &mut this.sync_buf,
-                                        );
-                                        for chunk in chunks.into_iter().rev() {
-                                            if let StreamChunk::Sync(ready) =
-                                                chunk
-                                            {
-                                                this.sync_buf.push_str(&ready);
-                                            } else {
-                                                this.chunks.push_front(chunk);
-                                            }
-                                        }
-                                        OooChunk::push_end_with_nonce(
-                                            replace,
-                                            &id,
-                                            &mut this.sync_buf,
-                                            nonce.as_deref(),
-                                        );
                                     }
+                                    OooChunk::push_end_with_nonce(
+                                        replace,
+                                        &id,
+                                        &mut this.sync_buf,
+                                        nonce.as_deref(),
+                                    );
                                 }
-                                Poll::Pending => {
-                                    this.pending_ooo.push_back(chunk);
+                                self.poll_next(cx)
+                            }
+                            Poll::Pending => {
+                                this.pending_ooo.push_back(pending);
+                                if this.sync_buf.is_empty() {
+                                    Poll::Pending
+                                } else {
+                                    Poll::Ready(Some(mem::take(
+                                        &mut this.sync_buf,
+                                    )))
                                 }
                             }
                         }
-
-                        if this.sync_buf.is_empty() {
-                            Poll::Pending
-                        } else {
-                            Poll::Ready(Some(mem::take(&mut this.sync_buf)))
-                        }
+                    } else if this.sync_buf.is_empty() {
+                        Poll::Ready(None)
+                    } else {
+                        Poll::Ready(Some(mem::take(&mut this.sync_buf)))
                     }
                 }
                 Some(StreamChunk::Sync(value)) => {