docs: remove deprecated Phoenix.SessionProcess.Redux references from README

- Removed "Advanced: Redux-Style State (Optional)" section showing deprecated Phoenix.SessionProcess.Redux struct-based API
- Removed "Redux with Subscriptions and Selectors" example using deprecated Redux module
- Removed "Redux with LiveView" example using deprecated Redux.LiveView alias
- Removed comparison table that included deprecated Redux column
- Removed deprecated LiveView integration section with deprecation notice
- Removed telemetry events section specific to deprecated Redux module

All remaining "Redux" references in README.md now refer to the current
Redux Store API (v1.0.0) which is built directly into SessionProcess.

Related: v1.0.0 removed Phoenix.SessionProcess.Redux module

Author: GSMLG-BOT

README.md

@@ -280,97 +280,6 @@ end
 
 ---
 
-> **Deprecation Notice**: The following section shows the old Redux API which is deprecated as of v0.6.0.
-> Please migrate to the new Redux Store API shown above.
-
-### With LiveView Integration (Redux-Based) - **DEPRECATED**
-
-Phoenix.SessionProcess provides Redux-based LiveView integration for real-time state synchronization.
-
-**This approach is deprecated** - use the Redux Store API (see above) instead.
-
-#### Session Process with Redux - **DEPRECATED**
-
-```elixir
-defmodule MyApp.SessionProcess do
-  use Phoenix.SessionProcess, :process
-  alias Phoenix.SessionProcess.Redux
-
-  @impl true
-  def init(_init_arg) do
-    redux = Redux.init_state(%{user: nil, count: 0})
-    {:ok, %{redux: redux}}
-  end
-
-  @impl true
-  def handle_call(:get_redux_state, _from, state) do
-    {:reply, {:ok, state.redux}, state}
-  end
-
-  @impl true
-  def handle_cast({:set_user, user}, state) do
-    # Dispatch action - Redux handles all notifications automatically
-    new_redux = Redux.dispatch(state.redux, {:set_user, user}, &reducer/2)
-    {:noreply, %{state | redux: new_redux}}
-  end
-
-  @impl true
-  def handle_cast(:increment, state) do
-    new_redux = Redux.dispatch(state.redux, :increment, &reducer/2)
-    {:noreply, %{state | redux: new_redux}}
-  end
-
-  defp reducer(state, action) do
-    case action do
-      {:set_user, user} -> %{state | user: user}
-      :increment -> %{state | count: state.count + 1}
-      _ -> state
-    end
-  end
-end
-```
-
-#### LiveView with Redux Integration
-
-```elixir
-defmodule MyAppWeb.DashboardLive do
-  use Phoenix.LiveView
-  alias Phoenix.SessionProcess.LiveView, as: SessionLV
-
-  def mount(_params, %{"session_id" => session_id}, socket) do
-    # Subscribe to Redux state and get initial state
-    case SessionLV.mount_session(socket, session_id) do
-      {:ok, socket, state} ->
-        {:ok, assign(socket, state: state, session_id: session_id)}
-
-      {:error, _reason} ->
-        {:ok, redirect(socket, to: "/login")}
-    end
-  end
-
-  # Automatically receive Redux state updates
-  def handle_info({:redux_state_change, %{state: new_state}}, socket) do
-    {:noreply, assign(socket, state: new_state)}
-  end
-
-  # Send messages to session
-  def handle_event("increment", _params, socket) do
-    SessionLV.dispatch_async(socket.assigns.session_id, "increment")
-    {:noreply, socket}
-  end
-
-  # Clean up subscription on terminate
-  def terminate(_reason, socket) do
-    SessionLV.unmount_session(socket)
-    :ok
-  end
-end
-```
-
-#### Configuration for LiveView
-
-**Important**: LiveView integration requires Redux for state management.
-
 ## API Reference
 
 ### Starting Sessions
@@ -559,225 +468,8 @@ end
 
 This is idiomatic Elixir and gives you full control over your state transitions.
 
-### Advanced: Redux-Style State (Optional)
-
-For complex applications requiring audit trails or time-travel debugging, you can optionally use `Phoenix.SessionProcess.Redux`:
-
-```elixir
-defmodule MyApp.ReduxSessionProcess do
-  use Phoenix.SessionProcess, :process
-  alias Phoenix.SessionProcess.Redux
-
-  @impl true
-  def init(_init_arg) do
-    initial_state = %{
-      user: nil,
-      preferences: %{},
-      cart: [],
-      activity_log: []
-    }
-
-    redux = Redux.init_state(initial_state, reducer: &reducer/2)
-    {:ok, %{redux: redux}}
-  end
-
-  # Define reducer to handle all state changes
-  def reducer(state, action) do
-    case action do
-      {:set_user, user} ->
-        %{state | user: user}
-
-      {:update_preferences, prefs} ->
-        %{state | preferences: Map.merge(state.preferences, prefs)}
-
-      {:add_to_cart, item} ->
-        %{state | cart: [item | state.cart]}
-
-      {:remove_from_cart, item_id} ->
-        cart = Enum.reject(state.cart, &(&1.id == item_id))
-        %{state | cart: cart}
-
-      :clear_cart ->
-        %{state | cart: []}
-
-      {:log_activity, activity} ->
-        log = [activity | state.activity_log]
-        %{state | activity_log: log}
-
-      :reset ->
-        %{user: nil, preferences: %{}, cart: [], activity_log: []}
-
-      _ ->
-        state
-    end
-  end
-
-  @impl true
-  def handle_call(:get_state, _from, %{redux: redux} = state) do
-    current_state = Redux.current_state(redux)
-    {:reply, current_state, state}
-  end
-
-  @impl true
-  def handle_call(:get_history, _from, %{redux: redux} = state) do
-    history = Redux.history(redux)
-    {:reply, history, state}
-  end
-
-  @impl true
-  def handle_cast({:dispatch, action}, %{redux: redux} = state) do
-    new_redux = Redux.dispatch(redux, action)
-    {:noreply, %{state | redux: new_redux}}
-  end
-end
-
-# Usage
-Phoenix.SessionProcess.start("session_123", MyApp.ReduxSessionProcess)
-Phoenix.SessionProcess.cast("session_123", {:dispatch, {:set_user, %{id: 1, name: "Alice"}}})
-Phoenix.SessionProcess.cast("session_123", {:dispatch, {:add_to_cart, %{id: 101, name: "Widget", price: 29.99}}})
-
-{:ok, state} = Phoenix.SessionProcess.call("session_123", :get_state)
-{:ok, history} = Phoenix.SessionProcess.call("session_123", :get_history)
-```
-
-#### Redux with Subscriptions and Selectors
-
-React to specific state changes with subscriptions and selectors:
-
-```elixir
-defmodule MyApp.ReactiveSession do
-  use Phoenix.SessionProcess, :process
-  alias Phoenix.SessionProcess.Redux
-  alias Phoenix.SessionProcess.Redux.Selector
-
-  @impl true
-  def init(_init_arg) do
-    redux = Redux.init_state(%{user: nil, cart: [], total: 0})
-
-    # Subscribe to user changes
-    redux =
-      Redux.subscribe(redux, fn state -> state.user end, fn user ->
-        IO.inspect(user, label: "User changed")
-      end)
-
-    # Subscribe with memoized selector for cart total
-    cart_total_selector =
-      Selector.create_selector(
-        [fn state -> state.cart end],
-        fn cart ->
-          Enum.reduce(cart, 0, fn item, acc -> acc + item.price end)
-        end
-      )
-
-    redux =
-      Redux.subscribe(redux, cart_total_selector, fn total ->
-        IO.inspect(total, label: "Cart total")
-      end)
-
-    {:ok, %{redux: redux}}
-  end
-
-  @impl true
-  def handle_call({:dispatch, action}, _from, state) do
-    new_redux = Redux.dispatch(state.redux, action, &reducer/2)
-    {:reply, {:ok, Redux.get_state(new_redux)}, %{state | redux: new_redux}}
-  end
-
-  defp reducer(state, action) do
-    case action do
-      {:set_user, user} -> %{state | user: user}
-      {:add_to_cart, item} -> %{state | cart: [item | state.cart]}
-      {:clear_cart} -> %{state | cart: []}
-      _ -> state
-    end
-  end
-end
-```
-
-#### Redux with LiveView
-
-Automatically update LiveView assigns from Redux state:
-
-```elixir
-defmodule MyAppWeb.ShoppingCartLive do
-  use Phoenix.LiveView
-  alias Phoenix.SessionProcess.Redux.LiveView, as: ReduxLV
-  alias Phoenix.SessionProcess.Redux.Selector
-
-  def mount(_params, %{"session_id" => session_id}, socket) do
-    if connected?(socket) do
-      # Define selectors
-      cart_count_selector = Selector.create_selector(
-        [fn state -> state.cart end],
-        fn cart -> length(cart) end
-      )
-
-      cart_total_selector = Selector.create_selector(
-        [fn state -> state.cart end],
-        fn cart -> Enum.reduce(cart, 0, &(&1.price + &2)) end
-      )
-
-      # Auto-subscribe to Redux changes
-      socket =
-        ReduxLV.assign_from_session(socket, session_id, %{
-          user: fn state -> state.user end,
-          cart_count: cart_count_selector,
-          cart_total: cart_total_selector
-        })
-
-      {:ok, assign(socket, session_id: session_id)}
-    else
-      {:ok, assign(socket, session_id: session_id, user: nil, cart_count: 0, cart_total: 0)}
-    end
-  end
-
-  # Handle automatic Redux assign updates
-  def handle_info({:redux_assign_update, key, value}, socket) do
-    {:noreply, ReduxLV.handle_assign_update(socket, key, value)}
-  end
-
-  def handle_event("add_item", %{"item" => item}, socket) do
-    ReduxLV.dispatch_to_session(socket.assigns.session_id, {:add_to_cart, item})
-    {:noreply, socket}
-  end
-
-  def render(assigns) do
-    ~H\"\"\"
-    <div>
-      <h2>Welcome, <%= @user.name %></h2>
-      <p>Cart: <%= @cart_count %> items</p>
-      <p>Total: $<%= @cart_total %></p>
-    </div>
-    \"\"\"
-  end
-end
-```
-
-**Redux Features:**
-- **Time-travel debugging** - Access complete action history
-- **Middleware support** - Add logging, validation, side effects
-- **Subscriptions** - React to specific state changes with callbacks
-- **Selectors with memoization** - Efficient derived state computation
-- **LiveView integration** - Automatic assign updates
-- **State persistence** - Serialize and restore state
-- **Predictable updates** - All changes through explicit actions
-- **Comprehensive telemetry** - Monitor Redux operations
-
-**Best for:** Complex applications, team collaboration, debugging requirements, state persistence needs, real-time reactive UIs.
-
-### Comparison
 
-| Feature | Basic GenServer | Agent State | Redux |
-|---------|----------------|-------------|-------|
-| Complexity | Low | Very Low | Medium |
-| Performance | Excellent | Excellent | Good |
-| Debugging | Manual | Manual | Built-in |
-| Time-travel | No | No | Yes |
-| Middleware | Manual | No | Yes |
-| State History | No | No | Yes |
-| Learning Curve | Low | Very Low | Medium |
 
-See [MIGRATION_GUIDE.md](MIGRATION_GUIDE.md) for detailed Redux migration guide and examples.
 
 ## Configuration Options
 
@@ -806,13 +498,6 @@ The library emits comprehensive telemetry events for monitoring and debugging:
 - `[:phoenix, :session_process, :cleanup]` - When a session is cleaned up
 - `[:phoenix, :session_process, :cleanup_error]` - When cleanup fails
 
-### Redux State Management Events
-- `[:phoenix, :session_process, :redux, :dispatch]` - When a Redux action is dispatched
-- `[:phoenix, :session_process, :redux, :subscribe]` - When a subscription is created
-- `[:phoenix, :session_process, :redux, :unsubscribe]` - When a subscription is removed
-- `[:phoenix, :session_process, :redux, :notification]` - When subscriptions are notified
-- `[:phoenix, :session_process, :redux, :selector_cache_hit]` - When selector cache is hit
-- `[:phoenix, :session_process, :redux, :selector_cache_miss]` - When selector cache misses
 
 ### Example Telemetry Setup