refactor!: prepare for v1.0.0 - rename @Prefix to @action_prefix and unify dispatch API

BREAKING CHANGES:

1. Renamed @Prefix to @action_prefix in reducer system
   - All reducer modules must update from @Prefix to @action_prefix
   - @action_prefix can be nil or "" for catch-all reducers
   - Generated function renamed: __reducer_prefix__ → __reducer_action_prefix__

2. Changed dispatch return values to :ok
   - dispatch/3 now returns :ok instead of {:ok, state}
   - dispatch_async/3 now returns :ok instead of {:ok, state}
   - All dispatches are now async (fire-and-forget)
   - Use get_state/1-2 to retrieve state after dispatch

3. Added dispatch_async/3 function
   - New explicit async dispatch function for clarity
   - Same behavior as dispatch/3 but clearer intent

MIGRATION:

For @Prefix rename:
- Find: @Prefix
- Replace: @action_prefix

For dispatch return values:
- Find: {:ok, state} = SessionProcess.dispatch(...)
- Replace: :ok = SessionProcess.dispatch(...)
- Add: state = SessionProcess.get_state(session_id)

Files changed:
- lib/phoenix/session_process.ex
- lib/phoenix/session_process/redux/reducer_compiler.ex
- test/phoenix/session_process/dispatch_test.exs
- test/phoenix/session_process/reducer_integration_test.exs
- README.md
- CLAUDE.md
- CHANGELOG.md

New documentation:
- V1_0_0_PREPARATION.md - Comprehensive v1.0.0 preparation guide
- REDUCER_IMPROVEMENTS.md - Reducer system improvement tracking

All 264 tests passing.

Author: GSMLG-BOT

CHANGELOG.md

@@ -5,6 +5,90 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased] - v1.0.0
+
+### Breaking Changes
+
+- **Renamed `@prefix` to `@action_prefix` in reducer modules**
+  - All reducer modules must now use `@action_prefix` instead of `@prefix`
+  - The `@action_prefix` can be `nil` or `""` to create catch-all reducers that handle all actions
+  - Migration: Simply rename `@prefix` to `@action_prefix` in your reducer modules
+  - Example:
+    ```elixir
+    # Before (v0.x)
+    defmodule MyReducer do
+      use Phoenix.SessionProcess, :reducer
+      @name :my_reducer
+      @prefix "my"  # Old name
+    end
+
+    # After (v1.0.0)
+    defmodule MyReducer do
+      use Phoenix.SessionProcess, :reducer
+      @name :my_reducer
+      @action_prefix "my"  # New name
+    end
+    ```
+
+- **Changed `dispatch/3` and `dispatch_async/3` return values**
+  - Both functions now return `:ok` instead of `{:ok, new_state}`
+  - All dispatches are now async (fire-and-forget) by default
+  - Use `get_state/1-2` to retrieve state after dispatch
+  - Migration:
+    ```elixir
+    # Before (v0.x)
+    {:ok, new_state} = SessionProcess.dispatch(session_id, :increment)
+    IO.inspect(new_state)
+
+    # After (v1.0.0)
+    :ok = SessionProcess.dispatch(session_id, :increment)
+    new_state = SessionProcess.get_state(session_id)
+    IO.inspect(new_state)
+    ```
+
+- **Removed deprecated `Phoenix.SessionProcess.Redux` module**
+  - The old struct-based Redux API has been removed
+  - Use the Redux Store API (built into SessionProcess) instead
+  - See migration guide: `REDUX_TO_SESSIONPROCESS_MIGRATION.md`
+
+### Added
+
+- **`dispatch_async/3` function for explicit async dispatch**
+  - Same behavior as `dispatch/3` but with clearer naming for async operations
+  - Makes code intent more explicit when dispatching async actions
+  - Example: `:ok = SessionProcess.dispatch_async(session_id, :increment)`
+
+### Changed
+
+- **Improved action routing with `@action_prefix`**
+  - More consistent naming aligns with action routing semantics
+  - Catch-all reducers now explicitly use `nil` or `""` for `@action_prefix`
+  - Better documentation and examples for action routing
+
+### Migration Guide
+
+1. **Rename `@prefix` to `@action_prefix` in all reducer modules**
+   - Search your codebase for `@prefix` in reducer modules
+   - Replace with `@action_prefix`
+   - No logic changes required
+
+2. **Update dispatch call sites to handle `:ok` return value**
+   - Replace `{:ok, state} = dispatch(...)` with `:ok = dispatch(...)`
+   - Add `get_state(session_id)` calls where you need the updated state
+   - Consider: Do you actually need the state? Many dispatches are fire-and-forget
+
+3. **Remove uses of deprecated Redux module**
+   - If using `Phoenix.SessionProcess.Redux` struct-based API
+   - Migrate to Redux Store API (SessionProcess IS the store)
+   - See `REDUX_TO_SESSIONPROCESS_MIGRATION.md` for detailed migration
+
+### Notes
+
+- All changes are breaking but migrations are straightforward
+- Most codebases will only need to rename `@prefix` to `@action_prefix`
+- Dispatch return value change makes async nature more explicit
+- v0.9.x will be the last version supporting deprecated APIs
+
 ## [0.6.0] - 2025-10-29
 
 ### Added

CLAUDE.md

@@ -277,8 +277,8 @@ session_id = conn.assigns.session_id
 # Start session
 Phoenix.SessionProcess.start(session_id, MyApp.SessionProcess)
 
-# Register reducer
-reducer = fn state, action ->
+# Register reducer (note: first parameter is action, second is state)
+reducer = fn action, state ->
   case action do
     :increment -> %{state | count: state.count + 1}
     {:set_user, user} -> %{state | user: user}
@@ -288,8 +288,11 @@ end
 
 Phoenix.SessionProcess.register_reducer(session_id, :main, reducer)
 
-# Dispatch actions
-{:ok, new_state} = Phoenix.SessionProcess.dispatch(session_id, :increment)
+# Dispatch actions (returns :ok, all dispatches are async)
+:ok = Phoenix.SessionProcess.dispatch(session_id, :increment)
+
+# Get state after dispatch
+state = Phoenix.SessionProcess.get_state(session_id)
 ```
 
 **LiveView (NEW API):**
@@ -366,16 +369,19 @@ SessionProcess itself is a Redux store with built-in infrastructure:
 # Define initial state
 def user_init(_), do: %{count: 0}
 
-# Register reducer
-SessionProcess.register_reducer(session_id, :counter, fn state, action ->
+# Register reducer (note: first parameter is action, second is state)
+SessionProcess.register_reducer(session_id, :counter, fn action, state ->
   case action do
     :increment -> %{state | count: state.count + 1}
     _ -> state
   end
 end)
 
-# Dispatch actions
-{:ok, new_state} = SessionProcess.dispatch(session_id, :increment)
+# Dispatch actions (returns :ok)
+:ok = SessionProcess.dispatch(session_id, :increment)
+
+# Get state after dispatch
+state = SessionProcess.get_state(session_id)
 
 # Subscribe with selector
 {:ok, sub_id} = SessionProcess.subscribe(

README.md

@@ -147,6 +147,8 @@ end
 
 Phoenix.SessionProcess now includes built-in Redux functionality - **SessionProcess IS the Redux store**. No need to manage separate Redux structs or manual state updates.
 
+> **Note**: v1.0.0 is coming soon with enhanced reducer routing and action normalization. See CHANGELOG.md for details.
+
 #### Session Process as Redux Store
 
 ```elixir
@@ -163,7 +165,7 @@ end
 {:ok, _pid} = Phoenix.SessionProcess.start(session_id, MyApp.SessionProcess)
 
 # Register a reducer
-reducer = fn state, action ->
+reducer = fn action, state ->
   case action do
     {:set_user, user} -> %{state | user: user}
     :increment -> %{state | count: state.count + 1}
@@ -173,11 +175,14 @@ end
 
 Phoenix.SessionProcess.register_reducer(session_id, :main, reducer)
 
-# Dispatch actions (synchronous)
-{:ok, new_state} = Phoenix.SessionProcess.dispatch(session_id, {:set_user, %{id: 123, name: "Alice"}})
+# Dispatch actions (all dispatches are async and return :ok)
+:ok = Phoenix.SessionProcess.dispatch(session_id, {:set_user, %{id: 123, name: "Alice"}})
+
+# Or use dispatch_async for clarity (same behavior)
+:ok = Phoenix.SessionProcess.dispatch_async(session_id, :increment)
 
-# Dispatch actions (asynchronous)
-:ok = Phoenix.SessionProcess.dispatch(session_id, :increment, async: true)
+# Get state after dispatch
+state = Phoenix.SessionProcess.get_state(session_id)
 
 # Subscribe to state changes
 Phoenix.SessionProcess.subscribe(
@@ -405,8 +410,8 @@ end
 The built-in Redux Store API provides state management with actions, reducers, and subscriptions:
 
 ```elixir
-# Register a reducer
-reducer = fn state, action ->
+# Register a reducer (note: first parameter is action, second is state)
+reducer = fn action, state ->
   case action do
     {:set_user, user} -> %{state | user: user}
     :increment -> %{state | count: state.count + 1}
@@ -416,17 +421,17 @@ end
 
 Phoenix.SessionProcess.register_reducer(session_id, :main_reducer, reducer)
 
-# Dispatch actions (synchronous - returns new state)
-{:ok, new_state} = Phoenix.SessionProcess.dispatch(session_id, {:set_user, %{id: 123}})
+# Dispatch actions (all dispatches return :ok and are async)
+:ok = Phoenix.SessionProcess.dispatch(session_id, {:set_user, %{id: 123}})
 
-# Dispatch actions (asynchronous - fire and forget)
-:ok = Phoenix.SessionProcess.dispatch(session_id, :increment, async: true)
+# Or use dispatch_async for clarity (same behavior)
+:ok = Phoenix.SessionProcess.dispatch_async(session_id, :increment)
 
-# Get current state
-{:ok, state} = Phoenix.SessionProcess.get_state(session_id)
+# Get current state after dispatch
+state = Phoenix.SessionProcess.get_state(session_id)
 
 # Get state with selector
-{:ok, user} = Phoenix.SessionProcess.get_state(session_id, fn state -> state.user end)
+user = Phoenix.SessionProcess.get_state(session_id, fn state -> state.user end)
 
 # Subscribe to state changes (with selector)
 {:ok, sub_id} = Phoenix.SessionProcess.subscribe(
@@ -449,7 +454,7 @@ user_name_selector = fn state -> state.user && state.user.name end
 :ok = Phoenix.SessionProcess.register_selector(session_id, :user_name, user_name_selector)
 
 # Use registered selector
-{:ok, name} = Phoenix.SessionProcess.select(session_id, :user_name)
+name = Phoenix.SessionProcess.select(session_id, :user_name)
 ```
 
 **Key Features:**