diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml
index 70f603c..6a503db 100644
--- a/.github/workflows/python-app.yml
+++ b/.github/workflows/python-app.yml
@@ -3,54 +3,90 @@ name: Python application
 on: [push, pull_request]
 
 jobs:
-  build:
-
+  test:
     runs-on: ubuntu-latest
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Fetch all history for versioning
 
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: '3.x'
 
-    - name: Install Poetry
-      run: |
-        curl -sSL https://install.python-poetry.org | python3 -
-
-    - name: Install dependencies with Poetry
+    - name: Install UV
       run: |
-        poetry install --with dev
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.cargo/bin" >> $GITHUB_PATH
 
-    - name: Install pre-commit
+    - name: Install dependencies with UV
       run: |
-        poetry run pip install pre-commit
+        uv sync
 
     - name: Run pre-commit
       run: |
-        poetry run pre-commit run --all-files
+        uv run pre-commit run --all-files
 
     - name: Install Playwright browsers
       run: |
-        poetry run playwright install
+        uv run playwright install
 
     - name: Run tests
       run: |
-        poetry run pytest --reruns 3 # githubs playwright sometimes fails
+        uv run pytest --reruns 3 # githubs playwright sometimes fails
+
+  publish:
+    needs: test
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write  # Allows pushing tags
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Fetch all history for versioning
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+
+    - name: Install UV
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+
+    - name: Install dependencies
+      run: |
+        uv sync
+
+    - name: Bump version and push tag
+      id: tag_version
+      uses: mathieudutour/github-tag-action@v6.1
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        default_bump: patch
+        tag_prefix: v
 
     - name: Build package
-      if: github.ref == 'refs/heads/main'
       run: |
-        python -m pip install --upgrade build
-        python -m build
+        uv build
 
     - name: Publish package to PyPI
-      if: github.ref == 'refs/heads/main'
       env:
-        TWINE_USERNAME: __token__
-        TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+        UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
       run: |
-        python -m pip install --upgrade twine
-        python -m twine upload dist/*
+        uv publish
+
+    - name: Create GitHub Release
+      uses: ncipollo/release-action@v1
+      with:
+        tag: ${{ steps.tag_version.outputs.new_tag }}
+        name: Release ${{ steps.tag_version.outputs.new_tag }}
+        body: ${{ steps.tag_version.outputs.changelog }}
diff --git a/.gitignore b/.gitignore
index ecc9912..56719c5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,9 @@
 Dockerfile
 example.py
 
+# Auto-generated version file
+hstream/_version.py
+
 .*pyc
 # Byte-compiled / optimized / DLL files
 __pycache__/
diff --git a/CONTRIBUTE.md b/CONTRIBUTE.md
index 72ceb9a..ee15d7a 100644
--- a/CONTRIBUTE.md
+++ b/CONTRIBUTE.md
@@ -1,15 +1,54 @@
 ## Deploy
 
-1. increment version in `setup.py`
+We use automatic versioning and deployment with hatch-vcs and GitHub Actions.
 
-2. `rm -rf build/ hstream.egg-info/ dist/`
+### How It Works:
 
-3. `pip install twine build`
+```
+Push to main → Tests pass → Auto-create tag → Build with version → Publish to PyPI → Create GitHub release
+```
 
-4. `python -m build`
+Every push to the main branch will:
+1. Run all tests
+2. Automatically create a new git tag (patch version bump: v0.1.58 → v0.1.59)
+3. Build the package with the version from the tag
+4. Publish to PyPI automatically
+5. Create a GitHub release with changelog
+
+### Important: Initial Setup Needed
+
+Before the auto-versioning works, you need to create an initial tag:
+
+```bash
+# Switch to main branch and create initial tag
+git checkout main
+git tag v0.1.58  # Use the next version number
+git push origin v0.1.58
+```
+
+After that, every push to main will auto-increment the patch version.
+
+### Manual Version Bumps
 
+The default is to bump the patch version (0.1.X), but you can control the version bump with commit messages:
+
+- **Patch bump** (default): `git commit -m "fix: bug fix"`
+- **Minor bump**: `git commit -m "feat: new feature"`
+- **Major bump**: `git commit -m "feat!: breaking change"`
+
+### Old Manual Process (Deprecated)
+
+<details>
+<summary>Click to see the old manual deployment process (no longer used)</summary>
+
+1. increment version in `setup.py`
+2. `rm -rf build/ hstream.egg-info/ dist/`
+3. `pip install twine build`
+4. `python -m build`
 5. `twine upload dist/*`
 
+</details>
+
 ## Kill orphaned uvicorn processes
 
 `kill -9 $(lsof -t -i:8000)` (or whatever port they we're using)
diff --git a/agents.md b/agents.md
index 23733c1..c238f96 100644
--- a/agents.md
+++ b/agents.md
@@ -1 +1 @@
-@architecture.md
\ No newline at end of file
+@architecture.md
diff --git a/architecture.md b/architecture.md
index b2ed4bc..e32b5a8 100644
--- a/architecture.md
+++ b/architecture.md
@@ -9,7 +9,7 @@ This flow covers the process from running the command to the user seeing the ini
 ```mermaid
 stateDiagram-v2
     direction LR
-    
+
     state "CLI & Server Startup" as Startup {
         [*] --> RunCommand: hstream run <script>
         RunCommand --> DjangoBoot: run_server()
@@ -67,6 +67,11 @@ stateDiagram-v2
 > **Swap vs Refresh Caveats**:
 > *   **Full Replace**: Used when the component structure changes significantly. This is the safest fallback but resets the DOM state (e.g., focus, scroll position) unless carefully managed.
 > *   **Partial Replace/Append**: HStream attempts to preserve the DOM by only updating changed elements (identified by consistent IDs). This maintains user focus and input state better than a full refresh.
+>
+> ```python
+> strategy = pick_a_strategy(prev_html, new_html, hs_script_running)
+> # Returns: "1_full_replace", "2_nothing", "3_partial_replace", or "4_partial_append"
+> ```
 
 
 ## Key File Descriptions
diff --git a/demo/example.py b/demo/example.py
index 359b438..c5f264f 100644
--- a/demo/example.py
+++ b/demo/example.py
@@ -35,14 +35,15 @@
     """
     )
 
-
     hs.markdown("""Or create forms like:""")
     with hs.html("form"):
         user_number = hs.number_input(
             "Input a number",
             default_value=0,
         )
-        hs.markdown(f"Your number is {'*even*' if int(user_number) % 2 == 0 else '*odd*'}")
+        hs.markdown(
+            f"Your number is {'*even*' if int(user_number) % 2 == 0 else '*odd*'}"
+        )
     with hs.html("header"):
         hs.markdown("## HStream also supports displaying plots")
     with hs.html("section"):
@@ -72,7 +73,7 @@
             fig, ax = plt.subplots()
             ax.plot(x, y)
             hs.pyplot(fig, key="myplot")
-        except Exception as e:
+        except Exception:
             hs.markdown(
                 "hmmm seems you don't have matplotlib installed, please install it with `pip install matplotlib`"
             )
diff --git a/demo/file upload.py b/demo/file upload.py
index 20481b9..6f9e31e 100644
--- a/demo/file upload.py	
+++ b/demo/file upload.py	
@@ -1,8 +1,9 @@
 from hstream import hs
+
 hs.markdown("# upload")
 uploaded_file = hs.file_upload("Upload your file")
 
 if uploaded_file and hs.button("Process and Download"):
-    hs.markdown('uploaded')
-    
+    hs.markdown("uploaded")
+
 hs.markdown(uploaded_file)
diff --git a/hstream/__init__.py b/hstream/__init__.py
index a0fc718..52fc2e5 100644
--- a/hstream/__init__.py
+++ b/hstream/__init__.py
@@ -1,5 +1,5 @@
 from hstream.hs import hs as hstream
-from hstream.components.components import component
+from hstream.components.components import component as component
 
 
 hs = hstream()
diff --git a/hstream/components/components.py b/hstream/components/components.py
index 97f908a..01c34db 100644
--- a/hstream/components/components.py
+++ b/hstream/components/components.py
@@ -48,7 +48,6 @@ def component(component_function):
     return wrapped_func
 
 
-
 class ComponentsGeneric:
     def get_key_based_on_call(self, message):
         """Displays a navigation bar with a list of items.
@@ -525,7 +524,7 @@ def write_dataframe(self, df, key: str = None, striped=False, **kwargs) -> None:
                 .replace('class="dataframe"', f'class="{striped}"')
             )
             self.doc.asis(html)
-            
+
     @component_wrapper
     def file_upload(
         self,
@@ -546,13 +545,16 @@ def file_upload(
         """
         with self.tag("label"):
             self.text(label)
-        
+
         # Check if we have a filename
         has_file = kwargs.get("value") and isinstance(kwargs["value"], str)
-        
+
         if has_file:
             # Show current file info with option to clear
-            with self.tag("div", style="margin: 5px 0; padding: 10px; background-color: #f0f0f0; border-radius: 3px; display: flex; justify-content: space-between; align-items: center;"):
+            with self.tag(
+                "div",
+                style="margin: 5px 0; padding: 10px; background-color: #f0f0f0; border-radius: 3px; display: flex; justify-content: space-between; align-items: center;",
+            ):
                 with self.tag("span"):
                     self.text(f"Current file: {kwargs['value']}")
                 with self.tag(
@@ -561,7 +563,7 @@ def file_upload(
                     ("hx-vals", '{"new_value": null}'),
                     ("hx-swap", "none"),
                     ("type", "button"),
-                    style="background-color: #ff4444; color: white; border: none; padding: 5px 10px; border-radius: 3px; cursor: pointer;"
+                    style="background-color: #ff4444; color: white; border: none; padding: 5px 10px; border-radius: 3px; cursor: pointer;",
                 ):
                     self.text("Remove")
         else:
@@ -577,6 +579,6 @@ def file_upload(
                 ("hx-encoding", "multipart/form-data"),
             ):
                 pass
-        
+
         # Return the filename directly
         return lambda x: str(x) if x else None
diff --git a/hstream/django_server/hs/views.py b/hstream/django_server/hs/views.py
index bb8ff98..beac9d6 100644
--- a/hstream/django_server/hs/views.py
+++ b/hstream/django_server/hs/views.py
@@ -82,7 +82,7 @@ def partial_or_full_html_content(request):
     update_strategy = pick_a_strategy(
         prev_html, html, get_session_var(request, "hs_script_running", False)
     )
-    # print(f"update strategy: {update_strategy}")
+    print(f"[DIFF_STRATEGY] Selected strategy: {update_strategy}")
     response = HttpResponse()
     if get_session_var(request, "hs_script_running", False):
         response.headers["HX-Trigger"] = "update_content_event"
@@ -173,44 +173,42 @@ def run_user_code_and_return_hs_instance(file: Path, request: HttpRequest) -> hs
     finally:
         set_session_var(request, "hs_script_should_stop", False)
     return users_hs_instance
-import os
-import tempfile
-from pathlib import Path
+
 
 def set_component_value(
     request: HttpRequest,
 ):
     component_id = request.GET.get("component_id")
-    
+
     request_server_stop_running_user_script(request, wait=True)
-    
+
     # Handle file uploads
     if request.FILES and "new_value" in request.FILES:
         uploaded_file = request.FILES["new_value"]
-        
+
         # Create tmp directory if it doesn't exist
         tmp_dir = Path("tmp")
         tmp_dir.mkdir(exist_ok=True)
-        
+
         # Save file to tmp directory
         file_path = tmp_dir / uploaded_file.name
-        with open(file_path, 'wb') as f:
+        with open(file_path, "wb") as f:
             for chunk in uploaded_file.chunks():
                 f.write(chunk)
-        
+
         # Set the filename as the value
         new_value = uploaded_file.name
-        print(f'File saved to: {file_path}')
-        
+        print(f"File saved to: {file_path}")
+
     else:
         # Handle regular form data
         new_value = request.POST.get("new_value")
         if new_value is None:
             new_value = request.GET.get("new_value")
-    
+
     set_session_var(request, component_id, new_value)
-    print('Component value set to:', new_value)
-    
+    print("Component value set to:", new_value)
+
     response = HttpResponse(f"suc: {request.session[component_id]}", status=200)
     response.headers["HX-Reswap"] = "none"
     response.headers["HX-Trigger"] = "trigger_run_hs_event"
diff --git a/pyproject.toml b/pyproject.toml
index 989956d..f4170d7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "hstream"
-version = "0.1.57"
+dynamic = ["version"]
 description = ""
 authors = [{ name = "Conrad", email = "conradbez1@gmail.com" }]
 readme = "README.md"
@@ -16,6 +16,12 @@ dependencies = [
 [project.scripts]
 hstream = "hstream.cli:cli"
 
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "hstream/_version.py"
+
 [tool.uv]
 dev-dependencies = [
     "black>=24.4.2",
@@ -32,5 +38,5 @@ dev-dependencies = [
 ]
 
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
diff --git a/test_custom_component.py b/test_custom_component.py
index 700eec5..6fa913f 100644
--- a/test_custom_component.py
+++ b/test_custom_component.py
@@ -1,22 +1,25 @@
 from hstream import hstream as hs
 from hstream import component
 
+
 @component
 def my_custom_component(self, label, key=None, **kwargs):
     with self.tag("div", ("class", "custom-component")):
         self.text(f"Custom: {label}")
     return "custom_value"
 
+
 def test_custom_component():
     # Verify the method exists on the hs instance
     assert hasattr(hs, "my_custom_component")
-    
-    # Verify it runs (this is a basic check, fully running it requires the django context usually, 
+
+    # Verify it runs (this is a basic check, fully running it requires the django context usually,
     # but we can check if the method is callable and returns what we expect from the wrapper)
     # Note: The wrapper expects 'key' or generates one, and interacts with _hs_session.
     # For this unit test, we might hit session errors if we run it fully without mocking.
     # Let's just check registration for now.
     print("Custom component registered successfully")
 
+
 if __name__ == "__main__":
     test_custom_component()
diff --git a/tests/test_diff_strategies.py b/tests/test_diff_strategies.py
new file mode 100644
index 0000000..fbea6e8
--- /dev/null
+++ b/tests/test_diff_strategies.py
@@ -0,0 +1,358 @@
+"""
+End-to-end tests for content update (diff) strategies.
+
+This module tests that the correct diff strategies are applied when users
+interact with hstream components, triggering different types of DOM updates.
+"""
+import platform
+from time import sleep
+from playwright.sync_api import sync_playwright
+from .conftest import write_py_script
+
+
+def wait_for_server():
+    """Wait for server to be ready on GitHub CI."""
+    if not platform.system() == "Darwin":
+        sleep(10)
+
+
+def setup_test_script(contents):
+    """Helper to write test script and wait for server."""
+    sleep(0)
+    write_py_script(contents=contents)
+    wait_for_server()
+
+
+def verify_strategy_in_logs(capsys, expected_strategy):
+    """
+    Verify that the expected diff strategy was logged by the server.
+
+    Args:
+        capsys: pytest's capsys fixture for capturing stdout/stderr
+        expected_strategy: The strategy string to look for (e.g., "1_full_replace")
+    """
+    captured = capsys.readouterr()
+    all_output = captured.out + captured.err
+    strategy_log = f"[DIFF_STRATEGY] Selected strategy: {expected_strategy}"
+    assert (
+        strategy_log in all_output
+    ), f"Expected strategy '{expected_strategy}' not found in logs. Output:\n{all_output[-2000:]}"
+
+
+def test_full_replace_strategy_on_initial_load(capsys):
+    """
+    Test that full replace strategy is used on initial page load.
+
+    Strategy: 1_full_replace
+    Trigger: First page load with no previous HTML
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+hs.markdown('# Initial Load')
+hs.markdown('This is the first render')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "1_full_replace")
+
+        # Verify content is present (full replace happened)
+        assert "Initial Load" in page.inner_text("body")
+        assert "This is the first render" in page.inner_text("body")
+        browser.close()
+
+
+def test_nothing_strategy_when_no_change(capsys):
+    """
+    Test that nothing strategy is used when user action doesn't change output.
+
+    Strategy: 2_nothing
+    Trigger: Button click that doesn't change any displayed content
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+# State that doesn't affect output
+clicked = hs.button('Click me (no visible change)')
+
+hs.markdown('Static content that never changes')
+hs.markdown('More static content')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        initial_content = page.inner_text("body")
+
+        # Click button but output remains the same
+        button = page.locator('button:has-text("Click me")')
+        button.click()
+        sleep(2)
+
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "2_nothing")
+
+        # Content should be identical (nothing strategy)
+        assert page.inner_text("body") == initial_content
+        browser.close()
+
+
+def test_partial_replace_strategy_when_content_changes(capsys):
+    """
+    Test that partial replace strategy is used when existing content changes.
+
+    Strategy: 3_partial_replace
+    Trigger: Text input that updates existing markdown elements
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+text = hs.text_input('Enter text', default_value='original')
+
+hs.markdown(f'You typed: {text}')
+hs.markdown('This line stays the same')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        assert "You typed: original" in page.inner_text("body")
+
+        # Type new text - this should trigger partial replace
+        text_input = page.locator("input[type=text]")
+        text_input.fill("updated")
+        text_input.press("Enter")
+        sleep(2)
+
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "3_partial_replace")
+
+        # Content should be updated (partial replace)
+        assert "You typed: updated" in page.inner_text("body")
+        assert "This line stays the same" in page.inner_text("body")
+        browser.close()
+
+
+def test_partial_replace_strategy_when_elements_removed(capsys):
+    """
+    Test that partial replace strategy is used when conditional elements are removed.
+
+    Strategy: 3_partial_replace
+    Trigger: Checkbox that controls visibility of elements (fewer elements shown)
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+show_extra = hs.checkbox('Show extra content', default_value=True)
+
+hs.markdown('Line 1: Always visible')
+hs.markdown('Line 2: Always visible')
+
+if show_extra:
+    hs.markdown('Line 3: Conditional')
+    hs.markdown('Line 4: Conditional')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        # Initially all 4 lines should be visible
+        assert "Line 1: Always visible" in page.inner_text("body")
+        assert "Line 3: Conditional" in page.inner_text("body")
+        assert "Line 4: Conditional" in page.inner_text("body")
+
+        # Uncheck to remove conditional elements (partial replace with fewer elements)
+        checkbox = page.locator("input[type=checkbox]")
+        checkbox.uncheck()
+        text_input = page.locator("input[type=text]")
+        text_input.focus()  # Trigger update
+        sleep(2)
+
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "3_partial_replace")
+
+        # Conditional lines should be gone
+        assert "Line 1: Always visible" in page.inner_text("body")
+        assert "Line 2: Always visible" in page.inner_text("body")
+        assert "Line 3: Conditional" not in page.inner_text("body")
+        browser.close()
+
+
+def test_partial_append_strategy_when_elements_added(capsys):
+    """
+    Test that partial append strategy is used when new elements are added.
+
+    Strategy: 4_partial_append
+    Trigger: Checkbox that shows additional content at the end
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+show_more = hs.checkbox('Show more content', default_value=False)
+
+hs.markdown('Line 1: Always here')
+hs.markdown('Line 2: Always here')
+
+if show_more:
+    hs.markdown('Line 3: Newly added')
+    hs.markdown('Line 4: Newly added')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        # Initially only 2 lines
+        assert "Line 1: Always here" in page.inner_text("body")
+        assert "Line 2: Always here" in page.inner_text("body")
+        assert "Line 3: Newly added" not in page.inner_text("body")
+
+        # Check box to add new elements (partial append)
+        checkbox = page.locator("input[type=checkbox]")
+        checkbox.check()
+        text_input = page.locator("input[type=text]")
+        text_input.focus()  # Trigger update
+        sleep(2)
+
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "4_partial_append")
+
+        # New lines should be appended
+        assert "Line 1: Always here" in page.inner_text("body")
+        assert "Line 2: Always here" in page.inner_text("body")
+        assert "Line 3: Newly added" in page.inner_text("body")
+        assert "Line 4: Newly added" in page.inner_text("body")
+        browser.close()
+
+
+def test_partial_append_with_counter(capsys):
+    """
+    Test partial append strategy with a counter that adds items incrementally.
+
+    Strategy: 4_partial_append
+    Trigger: Button clicks that add new list items
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+if hs.button('Add item'):
+    if 'count' not in hs.session_state:
+        hs.session_state['count'] = 1
+    else:
+        hs.session_state['count'] += 1
+
+count = hs.session_state.get('count', 0)
+
+hs.markdown('## Item List')
+for i in range(count):
+    hs.markdown(f'- Item {i + 1}')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        # Initially no items
+        initial_text = page.inner_text("body")
+        assert "Item 1" not in initial_text
+
+        # Click to add first item
+        button = page.locator('button:has-text("Add item")')
+        button.click()
+        sleep(2)
+        assert "Item 1" in page.inner_text("body")
+
+        # Click to add second item (partial append)
+        button.click()
+        sleep(2)
+
+        # Verify correct strategy was selected for append
+        verify_strategy_in_logs(capsys, "4_partial_append")
+
+        assert "Item 1" in page.inner_text("body")
+        assert "Item 2" in page.inner_text("body")
+
+        # Click to add third item (partial append)
+        button.click()
+        sleep(2)
+        assert "Item 1" in page.inner_text("body")
+        assert "Item 2" in page.inner_text("body")
+        assert "Item 3" in page.inner_text("body")
+        browser.close()
+
+
+def test_multiple_inputs_partial_replace(capsys):
+    """
+    Test partial replace with multiple interactive elements.
+
+    Strategy: 3_partial_replace
+    Trigger: Multiple inputs that change different parts of the content
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+name = hs.text_input('Name', default_value='Alice')
+age = hs.number_input('Age', default_value=25)
+
+hs.markdown(f'## User Profile')
+hs.markdown(f'Name: {name}')
+hs.markdown(f'Age: {age}')
+hs.markdown(f'Status: Active')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        assert "Name: Alice" in page.inner_text("body")
+        assert "Age: 25" in page.inner_text("body")
+
+        # Change name (partial replace)
+        text_input = page.locator("input[type=text]")
+        text_input.fill("Bob")
+        text_input.press("Enter")
+        sleep(2)
+
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "3_partial_replace")
+
+        assert "Name: Bob" in page.inner_text("body")
+        assert "Age: 25" in page.inner_text("body")
+        assert "Status: Active" in page.inner_text("body")
+
+        # Change age (partial replace)
+        number_input = page.locator("input[type=number]")
+        number_input.fill("30")
+        number_input.press("Enter")
+        sleep(2)
+
+        assert "Name: Bob" in page.inner_text("body")
+        assert "Age: 30" in page.inner_text("body")
+        browser.close()
diff --git a/uv.lock b/uv.lock
index 24de1e9..fb7d564 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.12'",
@@ -364,7 +364,6 @@ wheels = [
 
 [[package]]
 name = "hstream"
-version = "0.1.57"
 source = { editable = "." }
 dependencies = [
     { name = "beautifulsoup4" },