feat: Add init_state/0 callback to reducer modules

Reducers now define their own initial state via init_state/0, making them
fully self-contained and reusable.

Changes:
- Added init_state/0 callback to :reducer macro (defaults to %{})
- Modified :process init/1 to call each reducer's init_state/0
- Reducer slices are automatically initialized from reducer's init_state/0
- SessionProcess init_state/1 only needs to define non-reducer state

Benefits:
- Reducers are fully self-contained (state + actions + initialization)
- Reusable across different SessionProcesses
- Clear separation of concerns
- Parent process doesn't need to know reducer's state structure

Example:
```elixir
defmodule UserReducer do
  use Phoenix.SessionProcess, :reducer

  def init_state do
    %{users: [], loading: false, query: nil}
  end

  def handle_action(%{type: "add-user", payload: user}, state) do
    %{state | users: [user | state.users]}
  end
end

defmodule MyApp.SessionProcess do
  use Phoenix.SessionProcess, :process

  def init_state(_), do: %{global_count: 0}  # Only non-reducer state

  def combined_reducers do
    %{users: UserReducer}  # UserReducer.init_state/0 called automatically
  end
end
```

Tests:
- Added test verifying reducer init_state is called
- Updated reducers to define init_state/0
- All 230 tests passing (13 integration tests)

Documentation:
- Updated :reducer macro docs with init_state/0
- Added State Initialization section
- Updated examples to show init_state/0

Refs: User feedback requesting init_state for reducers

Author: GSMLG-BOT

lib/phoenix/session_process.ex

@@ -824,6 +824,10 @@ defmodule Phoenix.SessionProcess do
       defmodule MyApp.Reducers.UserReducer do
         use Phoenix.SessionProcess, :reducer
 
+        def init_state do
+          %{users: [], loading: false, query: nil}
+        end
+
         @throttle {"fetch-list", "3000ms"}
         def handle_action(%{type: "fetch-list"}, state) do
           # Throttled: Only executes once per 3 seconds
@@ -848,6 +852,7 @@ defmodule Phoenix.SessionProcess do
 
   ## Callbacks
 
+  - `init_state/0` - Define initial state for this reducer's slice (optional, defaults to `%{}`)
   - `handle_action/2` - Handle synchronous actions, return updated state
   - `handle_async/3` - Handle async actions with dispatch callback, return updated state
 
@@ -857,6 +862,12 @@ defmodule Phoenix.SessionProcess do
   - `@debounce {action_pattern, duration}` - Debounce action (delay execution, reset timer)
 
   Duration format: `"500ms"`, `"1s"`, `"5m"`, `"1h"`
+
+  ## State Initialization
+
+  Each reducer defines its initial state via `init_state/0`. When using `combined_reducers/0`,
+  the SessionProcess automatically calls each reducer's `init_state/0` to build the complete
+  initial state with each reducer's slice.
   """
   defmacro __using__(:reducer) do
     quote do
@@ -873,6 +884,27 @@ defmodule Phoenix.SessionProcess do
       # Hook to capture attributes when functions are defined
       @on_definition {Phoenix.SessionProcess, :__on_reducer_definition__}
 
+      @doc """
+      Initialize the reducer's state slice.
+
+      Override this function to provide the initial state for this reducer's slice.
+
+      ## Returns
+
+      - `initial_state` - The initial state map for this reducer
+
+      ## Examples
+
+          def init_state do
+            %{users: [], loading: false, query: nil}
+          end
+
+          def init_state do
+            %{items: [], total: 0}
+          end
+      """
+      def init_state, do: %{}
+
       @doc """
       Handle synchronous actions.
 
@@ -931,7 +963,7 @@ defmodule Phoenix.SessionProcess do
       """
       def handle_async(_action, _dispatch, state), do: state
 
-      defoverridable handle_action: 2, handle_async: 3
+      defoverridable init_state: 0, handle_action: 2, handle_async: 3
     end
   end
 
@@ -1004,13 +1036,26 @@ defmodule Phoenix.SessionProcess do
             %{}
           end
 
+        # Initialize state slices from each reducer's init_state
+        app_state =
+          Enum.reduce(combined, user_state, fn {slice_key, module}, acc_state ->
+            slice_initial_state =
+              if function_exported?(module, :init_state, 0) do
+                module.init_state()
+              else
+                %{}
+              end
+
+            Map.put(acc_state, slice_key, slice_initial_state)
+          end)
+
         # Build reducer map from combined_reducers
         redux_reducers = build_combined_reducers(combined)
 
         # Wrap in Redux infrastructure
         state = %{
-          # User's application state
-          app_state: user_state,
+          # User's application state (with initialized reducer slices)
+          app_state: app_state,
 
           # Redux infrastructure (internal, prefixed with _redux_)
           _redux_reducers: redux_reducers,

test/phoenix/session_process/reducer_integration_test.exs

@@ -7,6 +7,10 @@ defmodule Phoenix.SessionProcess.ReducerIntegrationTest do
   defmodule UserReducer do
     use Phoenix.SessionProcess, :reducer
 
+    def init_state do
+      %{users: [], fetch_count: 0, search_query: nil}
+    end
+
     @throttle {"fetch-users", "100ms"}
     def handle_action(%{type: "fetch-users"}, state) do
       Map.update(state, :fetch_count, 1, &(&1 + 1))
@@ -28,6 +32,10 @@ defmodule Phoenix.SessionProcess.ReducerIntegrationTest do
   defmodule CartReducer do
     use Phoenix.SessionProcess, :reducer
 
+    def init_state do
+      %{items: []}
+    end
+
     def handle_action(%{type: "add-item", payload: item}, state) do
       Map.update(state, :items, [item], &[item | &1])
     end
@@ -44,11 +52,8 @@ defmodule Phoenix.SessionProcess.ReducerIntegrationTest do
     use Phoenix.SessionProcess, :process
 
     def init_state(_arg) do
-      %{
-        global_count: 0,
-        users: %{users: [], fetch_count: 0, search_query: nil},
-        cart: %{items: []}
-      }
+      # Only define state not managed by reducers
+      %{global_count: 0}
     end
 
     def combined_reducers do
@@ -73,6 +78,19 @@ defmodule Phoenix.SessionProcess.ReducerIntegrationTest do
   end
 
   describe "reducer modules" do
+    test "verifies reducer init_state is called for each slice", %{session_id: session_id} do
+      state = SessionProcess.get_state(session_id)
+
+      # Verify users slice was initialized from UserReducer.init_state/0
+      assert state.users == %{users: [], fetch_count: 0, search_query: nil}
+
+      # Verify cart slice was initialized from CartReducer.init_state/0
+      assert state.cart == %{items: []}
+
+      # Verify global state from SessionProcess init_state/1
+      assert state.global_count == 0
+    end
+
     test "verifies reducer module metadata functions exist", %{session_id: _session_id} do
       # Check throttle metadata
       assert [{_, "100ms"}] = UserReducer.__reducer_throttles__()