🆓 Let's apply the Composable Architecture's new state sharing tools to something even more real world: our open source word game, isowords. It currently models its user settings as a cumbersome dependency that requires a lot of code to keep features in sync when settings change. We should be able to greatly simplify things with the `@Shared` property wrapper.

🆓 We finish refactoring the SyncUps application to use the Composable Architecture's all new state sharing tools. We will see that we can delete hundreds of lines of boilerplate of coordination between parent and child features, _and_ we won't have to sacrifice any testability, including the _exhaustive_ testability provided by the library.

🆓 In our last series we developed a wonderful way to share state between features in the Composable Architecture, and even persist it, all without sacrificing testability, but we also didn't get to show the (just now released) tools being used in real world applications, so let's do just that, starting with SyncUps.

🔒 It's incredible how easy `@Shared` makes it to persist complex data types to the file system, but currently it completely ruins our ability to test features that use it. Let's fix that, and we will also explore what it means to derive a small piece of shared state from a bigger piece of shared state.

🔒 While user defaults is convenient for persisting simple bits of state, more complex data types should be saved to the file system. This can be tricky to get right, and so we take the time to properly handle all of the edge cases.

🔒 We can now persist simple bits of state to user defaults using the `@Shared` property wrapper, but there is more work to be done. We need to observe changes to user defaults in order to play those changes back to `@Shared`, and we need to put in a bit of extra work to make everything testable.

🔒 Let's enhance the `@Shared` property wrapper with the concept of persistence. We will begin with user defaults, which is the simplest form of persistence on Apple's platforms, and that will set the stage for more complex forms of persistence in the future.

🔒 We will employ `@Shared`'s new testing capabilities in a complex scenario: a sign up flow. We

will see how a deeply nested integration of features all sharing the same state can be tested

simply, and we will see how we can leverage the same tricks employed by the test store to add

debug tools to reducers using shared state.

🔒 The `@Shared` property wrapper can effortlessly share state among features to build complex

flows quickly, but because it is powered by a reference type, it is not compatible with the

Composable Architecture's value-oriented testing tools. Let's address these shortcomings and

recover all of the library's testing niceties.

🔒 We finish building a complex, flow-based case study that leverages the new `@Shared` property

wrapper. Along the way we will flex recently added superpowers of the library, and we will

experience firsthand how simple this new model of shared state can be.