diff --git a/Sources/RecombinePackage/Action.swift b/Sources/RecombinePackage/Action.swift
new file mode 100644
index 0000000..3da5b62
--- /dev/null
+++ b/Sources/RecombinePackage/Action.swift
@@ -0,0 +1,11 @@
+//
+//  File.swift
+//  
+//
+//  Created by Lotte Tortorella on 30/10/20.
+//
+
+public enum ActionStrata<Raw, Refined> {
+    case raw(Raw)
+    case refined(Refined)
+}
diff --git a/Sources/RecombinePackage/Middleware.swift b/Sources/RecombinePackage/Middleware.swift
index 8bcfdc0..eabb736 100644
--- a/Sources/RecombinePackage/Middleware.swift
+++ b/Sources/RecombinePackage/Middleware.swift
@@ -6,17 +6,20 @@
 //  Copyright © 2019 Charlotte Tortorella. All rights reserved.
 //
 
+import Combine
+
 /**
  Middleware is a structure that allows you to modify, filter out and create more
  actions, before the action being handled reaches the store.
  */
-public struct Middleware<State, Action> {
-    typealias Transform = (State, Action) -> [Action]
-    internal let transform: Transform
+public struct Middleware<State, Input, Output> {
+    public typealias Function = (Publishers.Output<Published<State>.Publisher>, Input) -> AnyPublisher<Output, Never>
+    public typealias Transform<Result> = (Publishers.Output<Published<State>.Publisher>, Output) -> Result
+    internal let transform: Function
 
     /// Create a blank slate Middleware.
-    private init() {
-        self.transform = { [$1] }
+    public init() where Input == Output {
+        self.transform = { Just($1).eraseToAnyPublisher() }
     }
 
     /**
@@ -24,105 +27,48 @@ public struct Middleware<State, Action> {
      
      - parameter transform: The function that will be able to modify passed actions.
      */
-    internal init(_ transform: @escaping Transform) {
+    private init(_ transform: @escaping Function) {
         self.transform = transform
     }
-
-    /**
-     Initialises the middleware by concatenating the transformative functions from
-     the middleware that was passed in.
-     */
-    public init(_ middleware: Self...) {
-        self = .init(middleware)
-    }
-
-    /**
-     Initialises the middleware by concatenating the transformative functions from
-     the middleware that was passed in.
-     */
-    public init<S: Sequence>(_ middleware: S) where S.Element == Middleware {
-        self = middleware.reduce(.init()) {
-            $0.concat($1)
-        }
-    }
-
+    
     /// Concatenates the transform function of the passed `Middleware` onto the callee's transform.
-    public func concat(_ other: Middleware) -> Middleware {
-        .init { state, action in
-            self.transform(state, action).flatMap {
-                other.transform(state, $0)
-            }
-        }
-    }
-
-    /// Safe encapsulation of side effects guaranteed not to affect the action being passed through the middleware.
-    public func sideEffect(_ effect: @escaping (State, Action) -> Void) -> Self {
-        .init { state, action in
-            self.transform(state, action).map {
-                effect(state, $0)
-                return $0
-            }
-        }
-    }
-
-    /// Safe encapsulation of side effects guaranteed not to affect the action being passed through the middleware.
-    public static func sideEffect(_ effect: @escaping (State, Action) -> Void) -> Self {
-        Middleware().sideEffect(effect)
+    public func concat<Result>(_ other: Middleware<State, Output, Result>) -> Middleware<State, Input, Result> {
+        return map(other.transform)
     }
 
     /// Transform the action into another action.
-    public func map(_ transform: @escaping (State, Action) -> Action) -> Self {
-        .init { state, action in
-            self.transform(state, action).map {
-                transform(state, $0)
-            }
-        }
-    }
-
-    /// Transform the action into another action.
-    public static func map(_ transform: @escaping (State, Action) -> Action) -> Self {
-        Middleware().map(transform)
-    }
-
-    /// One to many pattern allowing one action to be turned into multiple.
-    public func flatMap<S: Sequence>(_ transform: @escaping (State, Action) -> S) -> Self where S.Element == Action {
+    public func map<Result, P: Publisher>(
+        _ transform: @escaping Transform<P>
+    ) -> Middleware<State, Input, Result> where P.Output == Result, P.Failure == Never {
         .init { state, action in
             self.transform(state, action).flatMap {
                 transform(state, $0)
             }
+            .eraseToAnyPublisher()
         }
     }
 
-    /// One to many pattern allowing one action to be turned into multiple.
-    public static func flatMap<S: Sequence>(_ transform: @escaping (State, Action) -> S) -> Self where S.Element == Action {
-        Middleware().flatMap(transform)
-    }
-
-    /// Filters while mapping actions to new actions.
-    public func filterMap(_ transform: @escaping (State, Action) -> Action?) -> Self {
-        .init { state, action in
-            self.transform(state, action).compactMap {
-                transform(state, $0)
-            }
-        }
-    }
-
-    /// Filters while mapping actions to new actions.
-    public static func filterMap(_ transform: @escaping (State, Action) -> Action?) -> Self {
-        Middleware().filterMap(transform)
-    }
-
     /// Drop the action iff `isIncluded(action) != true`.
-    public func filter(_ isIncluded: @escaping (State, Action) -> Bool) -> Self {
+    public func filter(_ isIncluded: @escaping Transform<Bool>) -> Self {
         .init { state, action in
             self.transform(state, action).filter {
                 isIncluded(state, $0)
             }
+            .eraseToAnyPublisher()
         }
     }
+}
+
+extension Middleware where Input == Output {
+    /// Transform the action into another action.
+    public static func map<Result, P: Publisher>(
+        _ transform: @escaping Transform<P>
+    ) -> Middleware<State, Input, Result> where P.Output == Result, P.Failure == Never {
+        Middleware<State, Input, Input>().map(transform)
+    }
 
     /// Drop the action iff `isIncluded(action) != true`.
-    public static func filter(_ isIncluded: @escaping (State, Action) -> Bool) -> Self {
-        Middleware().filter(isIncluded)
+    public static func filter(_ isIncluded: @escaping Transform<Bool>) -> Self {
+        Middleware<State, Input, Input>().filter(isIncluded)
     }
 }
diff --git a/Sources/RecombinePackage/Reducer.swift b/Sources/RecombinePackage/Reducer.swift
index 5fde54f..d6d41e3 100644
--- a/Sources/RecombinePackage/Reducer.swift
+++ b/Sources/RecombinePackage/Reducer.swift
@@ -14,7 +14,7 @@ public protocol Reducer {
     var transform: Transform { get }
     init()
     init(_ transform: Transform)
-    func reduce(state: State, actions: [Action]) -> State
+    func reduce(state: State, action: Action) -> State
     func concat<R: Reducer>(_ other: R) -> Self where R.Transform == Transform
 }
 
@@ -52,8 +52,8 @@ public struct PureReducer<State, Action>: Reducer {
         }
     }
     
-    public func reduce(state: State, actions: [Action]) -> State {
-        actions.reduce(state, transform)
+    public func reduce(state: State, action: Action) -> State {
+        transform(state, action)
     }
 }
 
@@ -80,7 +80,9 @@ public struct MutatingReducer<State, Action>: Reducer {
         }
     }
     
-    public func reduce(state: State, actions: [Action]) -> State {
-        actions.reduce(into: state, transform)
+    public func reduce(state: State, action: Action) -> State {
+        var s = state
+        transform(&s, action)
+        return s
     }
 }
diff --git a/Sources/RecombinePackage/Store.swift b/Sources/RecombinePackage/Store.swift
index a86cd15..6a991ef 100644
--- a/Sources/RecombinePackage/Store.swift
+++ b/Sources/RecombinePackage/Store.swift
@@ -8,42 +8,58 @@
 
 import Combine
 
-public class Store<State, Action>: ObservableObject {
+public class Store<State, RawAction, RefinedAction>: ObservableObject {
     @Published
     public private(set) var state: State
-    public let actions = PassthroughSubject<Action, Never>()
+    public let rawActions = PassthroughSubject<RawAction, Never>()
+    public let refinedActions = PassthroughSubject<RefinedAction, Never>()
     private var cancellables = Set<AnyCancellable>()
 
     public required init<S: Scheduler, R: Reducer>(
         state: State,
         reducer: R,
-        middleware: Middleware<State, Action> = .init(),
+        middleware: Middleware<State, RawAction, RefinedAction>,
         publishOn scheduler: S
-    ) where R.State == State, R.Action == Action {
+    ) where R.State == State, R.Action == RefinedAction {
         self.state = state
 
-        actions.scan(state) { state, action in
+        rawActions.flatMap { [unowned self] action in
+            middleware.transform(self.$state.prefix(1), action)
+        }
+        .subscribe(refinedActions)
+        .store(in: &cancellables)
+        
+        refinedActions.scan(state) { state, action in
             reducer.reduce(
                 state: state,
-                actions: middleware.transform(state, action)
+                action: action
             )
         }
-        .receive(on: scheduler).sink { [unowned self] state in
+        .receive(on: scheduler)
+        .sink { [unowned self] state in
             self.state = state
         }
         .store(in: &cancellables)
     }
 
-    public func lensing<SubState>(_ keyPath: KeyPath<State, SubState>) -> StoreTransform<State, SubState, Action> {
+    public func lensing<SubState>(_ keyPath: KeyPath<State, SubState>) -> StoreTransform<State, SubState, RawAction, RefinedAction> {
         .init(store: self, lensing: keyPath)
     }
 
-    open func dispatch(_ actions: Action...) {
-        dispatch(actions)
+    open func dispatch(refined actions: RefinedAction...) {
+        dispatch(refined: actions)
+    }
+
+    open func dispatch<S: Sequence>(refined actions: S) where S.Element == RefinedAction {
+        actions.forEach(self.refinedActions.send)
+    }
+
+    open func dispatch(raw actions: RawAction...) {
+        dispatch(raw: actions)
     }
 
-    open func dispatch<S: Sequence>(_ actions: S) where S.Element == Action {
-        actions.forEach(self.actions.send)
+    open func dispatch<S: Sequence>(raw actions: S) where S.Element == RawAction {
+        actions.forEach(self.rawActions.send)
     }
 }
 
@@ -53,22 +69,27 @@ extension Store: Subscriber {
         subscription.request(.unlimited)
     }
 
-    public func receive(_ input: Action) -> Subscribers.Demand {
-        actions.send(input)
+    public func receive(_ input: ActionStrata<RawAction, RefinedAction>) -> Subscribers.Demand {
+        switch input {
+        case let .raw(action):
+            rawActions.send(action)
+        case let .refined(action):
+            refinedActions.send(action)
+        }
         return .unlimited
     }
 
     public func receive(completion: Subscribers.Completion<Never>) {}
 }
 
-public class StoreTransform<Underlying, State, Action>: ObservableObject {
+public class StoreTransform<Underlying, State, RawAction, RefinedAction>: ObservableObject {
     @Published
     public private(set) var state: State
-    private let store: Store<Underlying, Action>
+    private let store: Store<Underlying, RawAction, RefinedAction>
     private let keyPath: KeyPath<Underlying, State>
     private var cancellables = Set<AnyCancellable>()
 
-    public required init(store: Store<Underlying, Action>, lensing keyPath: KeyPath<Underlying, State>) {
+    public required init(store: Store<Underlying, RawAction, RefinedAction>, lensing keyPath: KeyPath<Underlying, State>) {
         self.store = store
         self.keyPath = keyPath
         state = store.state[keyPath: keyPath]
@@ -80,16 +101,24 @@ public class StoreTransform<Underlying, State, Action>: ObservableObject {
             .store(in: &cancellables)
     }
 
-    public func lensing<SubState>(_ keyPath: KeyPath<State, SubState>) -> StoreTransform<Underlying, SubState, Action> {
+    public func lensing<SubState>(_ keyPath: KeyPath<State, SubState>) -> StoreTransform<Underlying, SubState, RawAction, RefinedAction> {
         .init(store: store, lensing: self.keyPath.appending(path: keyPath))
     }
 
-    open func dispatch(_ actions: Action...) {
-        store.dispatch(actions)
+    open func dispatch(refined actions: RefinedAction...) {
+        store.dispatch(refined: actions)
     }
 
-    open func dispatch<S: Sequence>(_ actions: S) where S.Element == Action {
-        store.dispatch(actions)
+    open func dispatch<S: Sequence>(refined actions: S) where S.Element == RefinedAction {
+        store.dispatch(refined: actions)
+    }
+    
+    open func dispatch(raw actions: RawAction...) {
+        store.dispatch(raw: actions)
+    }
+
+    open func dispatch<S: Sequence>(unrefined actions: S) where S.Element == RawAction {
+        store.dispatch(raw: actions)
     }
 }
 
@@ -99,8 +128,13 @@ extension StoreTransform: Subscriber {
         subscription.request(.unlimited)
     }
 
-    public func receive(_ input: Action) -> Subscribers.Demand {
-        store.dispatch(input)
+    public func receive(_ input: ActionStrata<RawAction, RefinedAction>) -> Subscribers.Demand {
+        switch input {
+        case let .raw(action):
+            store.dispatch(raw: action)
+        case let .refined(action):
+            store.dispatch(refined: action)
+        }
         return .unlimited
     }
 
diff --git a/Tests/RecombineTests/MiddlewareFakes.swift b/Tests/RecombineTests/MiddlewareFakes.swift
index 4b55305..a21b367 100644
--- a/Tests/RecombineTests/MiddlewareFakes.swift
+++ b/Tests/RecombineTests/MiddlewareFakes.swift
@@ -7,28 +7,32 @@
 //
 
 import Recombine
+import Combine
 
-let firstMiddleware = Middleware<TestStringAppState, SetAction>().map { state, action in
+let firstMiddleware = Middleware<TestStringAppState, SetAction, SetAction>.map { state, action -> Just<SetAction> in
     switch action {
     case let .string(value):
-        return .string(value + " First Middleware")
+        return Just(.string(value + " First Middleware"))
     default:
-        return action
+        return Just(action)
     }
 }
 
-let secondMiddleware = Middleware<TestStringAppState, SetAction>().map { state, action in
+let secondMiddleware = Middleware<TestStringAppState, SetAction, SetAction>.map { state, action -> Just<SetAction> in
     switch action {
     case let .string(value):
-        return .string(value + " Second Middleware")
+        return Just(.string(value + " Second Middleware"))
     default:
-        return action
+        return Just(action)
     }
 }
 
-let stateAccessingMiddleware = Middleware<TestStringAppState, SetAction>().map { state, action in
-    if case let .string(value) = action  {
-        return .string(state.testValue! + state.testValue!)
+let stateAccessingMiddleware = Middleware<TestStringAppState, SetAction, SetAction>().map { state, action -> AnyPublisher<SetAction, Never> in
+    if case let .string(value) = action {
+        return state.map {
+            .string($0.testValue! + $0.testValue!)
+        }
+        .eraseToAnyPublisher()
     }
-    return action
+    return Just(action).eraseToAnyPublisher()
 }
diff --git a/Tests/RecombineTests/StoreDispatchTests.swift b/Tests/RecombineTests/StoreDispatchTests.swift
index a679929..a3ed49e 100644
--- a/Tests/RecombineTests/StoreDispatchTests.swift
+++ b/Tests/RecombineTests/StoreDispatchTests.swift
@@ -10,7 +10,7 @@ import XCTest
 @testable import Recombine
 import Combine
 
-fileprivate typealias StoreTestType = Store<TestAppState, SetAction>
+fileprivate typealias StoreTestType = Store<TestAppState, SetAction, SetAction>
 
 class ObservableStoreDispatchTests: XCTestCase {
 
@@ -26,10 +26,10 @@ class ObservableStoreDispatchTests: XCTestCase {
      it subscribes to the property we pass in and dispatches any new values
      */
     func testLiftingWorksAsExpected() {
-        let subject = PassthroughSubject<SetAction, Never>()
-        store = Store(state: TestAppState(), reducer: reducer, publishOn: ImmediateScheduler.shared)
+        let subject = PassthroughSubject<ActionStrata<SetAction, SetAction>, Never>()
+        store = Store(state: TestAppState(), reducer: reducer, middleware: .init(), publishOn: ImmediateScheduler.shared)
         subject.subscribe(store)
-        subject.send(.int(20))
+        subject.send(.refined(.int(20)))
         XCTAssertEqual(store.state.testValue, 20)
     }
 }
diff --git a/Tests/RecombineTests/StoreMiddlewareTests.swift b/Tests/RecombineTests/StoreMiddlewareTests.swift
index 8796de3..e04e5ef 100644
--- a/Tests/RecombineTests/StoreMiddlewareTests.swift
+++ b/Tests/RecombineTests/StoreMiddlewareTests.swift
@@ -20,48 +20,41 @@ class StoreMiddlewareTests: XCTestCase {
         let store = Store(
             state: TestStringAppState(),
             reducer: testValueStringReducer,
-            middleware: Middleware(firstMiddleware, secondMiddleware),
+            middleware: firstMiddleware.concat(secondMiddleware),
             publishOn: ImmediateScheduler.shared
         )
         let action = SetAction.string("OK")
-        store.dispatch(action)
+        store.dispatch(raw: action)
 
         XCTAssertEqual(store.state.testValue, "OK First Middleware Second Middleware")
     }
 
-    /**
-     it middleware can access the store's state
-     */
-    func testMiddlewareCanAccessState() {
-        var value = "Incorrect"
-        let store = Store(
-            state: TestStringAppState(testValue: value),
-            reducer: testValueStringReducer,
-            middleware: stateAccessingMiddleware.sideEffect { _, _ in value = "Correct" },
-            publishOn: ImmediateScheduler.shared
-        )
-
-        store.dispatch(.string("Action That Won't Go Through"))
-
-        XCTAssertEqual(value, "Correct")
-    }
-
     /**
      it middleware should not be executed if the previous middleware returned nil
      */
     func testMiddlewareSkipsReducersWhenPassedNil() {
-        let filteringMiddleware1 = Middleware<TestStringAppState, SetAction>().filter({ _, _ in false }).sideEffect { _, _ in XCTFail() }
-        let filteringMiddleware2 = Middleware<TestStringAppState, SetAction>().filter({ _, _ in false }).filterMap { _, _ in XCTFail(); return nil }
+        let filteringMiddleware1 = Middleware<TestStringAppState, SetAction, SetAction>()
+            .filter { _, _ in false }
+            .map { _, _ -> Empty<SetAction, Never> in
+                XCTFail()
+                return Empty()
+            }
+        let filteringMiddleware2 = Middleware<TestStringAppState, SetAction, SetAction>()
+            .filter { _, _ in false }
+            .map { _, _ -> Empty<SetAction, Never> in
+                XCTFail()
+                return Empty()
+            }
 
         let state = TestStringAppState(testValue: "OK")
 
         var store = Store(
             state: state,
             reducer: testValueStringReducer,
-            middleware: Middleware(filteringMiddleware1, filteringMiddleware2),
+            middleware: filteringMiddleware1.concat(filteringMiddleware2),
             publishOn: ImmediateScheduler.shared
         )
-        store.dispatch(.string("Action That Won't Go Through"))
+        store.dispatch(raw: .string("Action That Won't Go Through"))
 
         store = Store(
             state: state,
@@ -69,7 +62,7 @@ class StoreMiddlewareTests: XCTestCase {
             middleware: filteringMiddleware1,
             publishOn: ImmediateScheduler.shared
         )
-        store.dispatch(.string("Action That Won't Go Through"))
+        store.dispatch(raw: .string("Action That Won't Go Through"))
 
         store = Store(
             state: state,
@@ -77,23 +70,22 @@ class StoreMiddlewareTests: XCTestCase {
             middleware: filteringMiddleware2,
             publishOn: ImmediateScheduler.shared
         )
-        store.dispatch(.string("Action That Won't Go Through"))
+        store.dispatch(raw: .string("Action That Won't Go Through"))
     }
 
     /**
      it actions should be multiplied via the increase function
      */
     func testMiddlewareMultiplies() {
-        let multiplexingMiddleware = Middleware<CounterState, SetAction>()
-            .flatMap { [$1, $1, $1] }
-            .filterMap { $1 }
+        let multiplexingMiddleware = Middleware<CounterState, SetAction, SetAction>()
+            .map { [$1, $1, $1].publisher }
         let store = Store(
             state: CounterState(count: 0),
             reducer: increaseByOneReducer,
             middleware: multiplexingMiddleware,
             publishOn: ImmediateScheduler.shared
         )
-        store.dispatch(.noop)
+        store.dispatch(raw: .noop)
         XCTAssertEqual(store.state.count, 3)
     }
 }
diff --git a/Tests/RecombineTests/StoreTests.swift b/Tests/RecombineTests/StoreTests.swift
index d515590..8046d12 100644
--- a/Tests/RecombineTests/StoreTests.swift
+++ b/Tests/RecombineTests/StoreTests.swift
@@ -24,7 +24,7 @@ class ObservableStoreTests: XCTestCase {
                 reducer: testReducer,
                 deInitAction: { deInitCount += 1 }
             )
-            Just(.int(100)).subscribe(store)
+            Just(.refined(.int(100))).subscribe(store)
             XCTAssertEqual(store.state.testValue, 100)
         }
 
@@ -33,7 +33,7 @@ class ObservableStoreTests: XCTestCase {
 }
 
 // Used for deinitialization test
-class DeInitStore<State>: Store<State, SetAction> {
+class DeInitStore<State>: Store<State, SetAction, SetAction> {
     var deInitAction: (() -> Void)?
 
     deinit {
@@ -43,7 +43,7 @@ class DeInitStore<State>: Store<State, SetAction> {
     convenience init(
         state: State,
         reducer: MutatingReducer<State, SetAction>,
-        middleware: Middleware<State, SetAction> = Middleware(),
+        middleware: Middleware<State, SetAction, SetAction> = .init(),
         deInitAction: @escaping () -> Void
     ) {
         self.init(
@@ -58,7 +58,7 @@ class DeInitStore<State>: Store<State, SetAction> {
     required init<S, R>(
         state: State,
         reducer: R,
-        middleware: Middleware<State, SetAction> = .init(),
+        middleware: Middleware<State, SetAction, SetAction> = .init(),
         publishOn scheduler: S
     ) where State == R.State, SetAction == R.Action, S : Scheduler, R : Reducer {
         super.init(