 		_validations.lifetime.ended.observeCompleted { d?.dispose() }
 
 		action = { input in
-			switch body(inner.cache.value, input) {
+			switch body(input) {
 			case let .success(innerResult):
 				inner.action(innerResult)
 

	///   - body: The closure to invoke for any proposed value to `self`.
	public convenience init<M: ComposableMutablePropertyProtocol>(
		_ inner: M,
		_ body: @escaping (M.Value, M.Value) -> Result<M.Value, TransactionError>
	) where M.Value == Value {
		self.init(inner, transform: { $0 }, body)
	}

	/// Create an `TransactionalProperty` that presents `inner` as an
	/// `TransactionalProperty` of `U` values and the same error type, and invoke
	/// `body` with the current value of `inner` and the proposed value whenever
	/// the setter is invoked.
	///
	/// If `success` is returned by `body`, the associated value would be
	/// persisted to `inner`. Otherwise, the failure would be emitted by the

		_ inner: TransactionalProperty<U, E>,
		transform: @escaping (U) -> Value,
		errorTransform: @escaping (E) -> TransactionError,
		_ body: @escaping (Value) -> Result<U, TransactionError>
	) {
		let current = inner.value
		let initialValidation = body(transform(current)).map { _ in }
		let _validations = MutableProperty<Result<(), TransactionError>>(initialValidation)

		self.lifetime = inner.lifetime
