pointfreeco/swift-composable-architecture

This system is the Composable Architecture, a state management library for Apple platforms that provides a structured approach to building user interfaces through reducers, effects, and dependency injection. It manages application state and side effects using a macro-based architecture that integrates with Swift Concurrency and the Observation framework, replacing older Combine-based patterns. The library supports both SwiftUI and UIKit, offering tools for navigation, presentation, and shared state persistence across iOS, macOS, tvOS, and watchOS.

50 changes.

The project underwent a major architectural overhaul to release Composable Architecture v2, replacing the Combine-based reducer and effect system with Swift Concurrency, macros, and the Observable framework. This shift was accompanied by a comprehensive modernization of all example applications, migrating them from UIKit and legacy patterns to SwiftUI, async/await, and the new macro-based API.

45 changes.

This period focused on migrating the Composable Architecture library and its example applications to version 1.0, introducing modern macros like @Reducer and @ObservableState alongside SwiftUI's NavigationStack. The Tic-Tac-Toe and SyncUps examples were rebuilt to demonstrate these new patterns, including dependency injection and comprehensive testing with Swift Testing. Documentation and internal utilities were updated to reflect the new API, emphasizing declarative reducer composition and simplified state management.

15 changes.

This period focused on integrating the Composable Architecture with SwiftUI's native Observation framework, introducing new view modifiers and binding helpers to replace legacy Perception-based tracking. The team significantly expanded the documentation by updating the Building SyncUps tutorial to demonstrate modern TCA patterns, including @Shared persistence, @Presents navigation, and Swift Testing. Additionally, the work included adding comprehensive UI tests for iOS 16 and 17 integration scenarios, implementing privacy manifests, and refactoring example code to adhere to Swift 6 standards.

The Integration example project now includes a dedicated Xcode workspace (Integration.xcworkspace) with standard IDE checks enabled. This ensures that the example project is opened and managed correctly within Xcode, providing a stable environment for running the integration tests and UI regressions mentioned in the associated commit.

Examples/Integration/Integration.xcodeproj/project.xcworkspace · high confidence

The Tic Tac Toe example application now includes core authentication logic, introducing \LoginCore\ and \TwoFactorCore\ modules. These new components implement the login flow and two-factor verification steps using the Composable Architecture, allowing users to authenticate via email and password before accessing the game features.

Examples/TicTacToe/tic-tac-toe/Sources/TwoFactorCore · high confidence

The Integration example app has been restructured to include separate test case groups for iOS 16 and iOS 17, allowing users to verify behavior across different SwiftUI and observation APIs. The app now features a main navigation menu with sections for 'iOS 17', 'iOS 16 + 17', and 'iOS 16', each linking to specific test views like ObservableBasicsView, BasicsView, and mixed scenarios such as NewContainsOldTestCase. Additionally, the app includes a debug logs overlay for UI testing and supports deep linking via the 'integration' URL scheme.

Examples/Integration/Integration · high confidence

The GameUIKit module now includes a GameViewController that renders the Tic-Tac-Toe board using UIKit components. This view controller manages the game UI, including the grid of buttons for cell interaction, a title label, and a 'Play again' button, while observing the game store to update the display based on the current board state, player turn, and game status.

Examples/TicTacToe/tic-tac-toe/Sources/GameUIKit · high confidence

The macro library now supports Apple's Observation framework by introducing the \@ObservableState\ macro, which generates the necessary \ObservableState\ conformance and tracking infrastructure (including \\$id\ and \\$willModify\) for state types. Additionally, a new \@Presents\ property wrapper macro is added to handle ephemeral presentation state, automatically generating the required accessors and wrapped properties to integrate with the observation registrar. These changes provide the foundational macro support for adopting the Observation architecture within the Composable Architecture.

Sources/ComposableArchitectureMacros · high confidence

The SyncUps example app now exposes its external capabilities through a dependency-injection layer, allowing the UI to be decoupled from system APIs. A new \OpenSettings\ dependency provides a standardized way to open the device settings screen, while a comprehensive \SpeechClient\ wraps the \Speech\ framework for audio transcription. The speech client includes a live implementation for production use, a preview value that simulates transcription with mock text, and a test value, enabling developers to build and test voice-driven features without requiring actual hardware or network access.

Examples/SyncUps/SyncUps/Dependencies · high confidence

Adds a new AuthenticationClient that exposes login and two-factor authentication capabilities via a dependency-injected interface, allowing the application to handle user credentials and two-factor codes while supporting test overrides.

Examples/TicTacToe/tic-tac-toe/Sources/AuthenticationClient · high confidence

The library now provides a \@resultBuilder\ named \ReducerBuilder\ that allows developers to combine multiple reducers into a single reducer by running them sequentially and merging their effects. This builder enables a more declarative syntax for defining reducer bodies, supporting features like conditional logic (\if\/\else\) and optional reducers, which simplifies the composition of complex state management logic.

Sources/ComposableArchitecture/Reducer · high confidence

The Tic Tac Toe example app now includes a concrete live implementation of the AuthenticationClient dependency. This new file provides the actual logic for the demo, simulating login and two-factor authentication flows with hardcoded credentials and delays, allowing users to test the authentication features within the example application.

Examples/TicTacToe/tic-tac-toe/Sources/AuthenticationClientLive · high confidence

A new documentation entry point titled 'Meet the Composable Architecture' has been added to the library's docc tutorials. This page serves as a hub for learning the library, organizing content into 'Essentials' (covering features, side effects, testing, and composition) and 'Navigation' (covering presentations, destinations, and stacks). It also provides links to external resources including Point-Free videos, community forums, sample code repositories like SyncUps and TicTacToe, and the full online documentation.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture · high confidence

The Tic-Tac-Toe example now includes a New Game screen built with UIKit, allowing users to enter names for Player X and Player O before starting a match. This view integrates with the Composable Architecture by binding text fields to the store and enabling the 'Let’s Play!' button only when both names are provided. It also handles navigation to the GameViewController when the user initiates the game.

Examples/TicTacToe/tic-tac-toe/Sources/NewGameUIKit · high confidence

The SyncUps example application has been introduced as a comprehensive demonstration of building a complex, real-world SwiftUI app using the Composable Architecture. This example, inspired by Apple's Scrumdinger tutorial, showcases best practices such as state-driven navigation (sheets, drill-downs, and alerts), type-safe identifiers via the Tagged library, and identified collections for robust data management. It features fully controlled dependencies for side effects like timers, speech recognition, and file persistence, enabling comprehensive automated testing and seamless Xcode preview support. The app includes a full test suite and covers features like meeting recording, attendee management, and data persistence.

Examples/SyncUps/SyncUps · high confidence

Added a new Tic-Tac-Toe example application demonstrating the Composable Architecture, featuring a login flow, a new-game setup screen, and the core game logic. The implementation uses the @Reducer macro, @ObservableState, and navigation patterns to manage state transitions between authentication, game configuration, and gameplay.

Examples/TicTacToe/tic-tac-toe/Sources/AppCore · high confidence

The library introduces two new dependency values, \\\.dismiss\ and \\\.isPresented\, to simplify managing presented features. \\\.dismiss\ provides a \DismissEffect\ that allows child reducers to dismiss their parent presentation (via \ifLet\ or \forEach\) directly, supporting optional animations or transactions. \\\.isPresented\ exposes a boolean indicating whether the current feature is being presented, helping prevent logic errors when dismissal is attempted outside a presentation context.

Sources/ComposableArchitecture/Dependencies · high confidence

The \Sources/ComposableArchitecture/Reducer/Reducers\ directory now includes a comprehensive set of new reducer types to enhance state management and debugging. \BindingReducer\ handles binding actions to update bindable state, while \CombineReducers\ allows grouping multiple reducers for shared modifiers. Debugging is improved with \DebugReducer\ (exposed via the \\_printChanges\ method), which logs actions and state diffs using \CustomDump\ and \Sharing\'s change tracking, and \SignpostReducer\, which instruments reducer execution and effect lifecycles for performance profiling. For feature composition, \Scope\ embeds child reducers into parent domains, \ifLet\ and \ifCaseLet\ handle optional and enum-based child states with automatic cancellation, \forEach\ manages collections of child features, and \OnChange\ triggers effects when specific state values change. Additional utilities include \DependencyKeyWritingReducer\ for overriding dependencies, \Reduce\ for inline logic, \EmptyReducer\ as a placeholder, \PresentationState\ for navigation modeling, and \Optional\ extension to treat optional reducers as no-ops when nil.

Sources/ComposableArchitecture/Reducer/Reducers · high confidence

Added a new documentation tutorial that guides users through recreating Apple's Scrumdinger demo application using the Composable Architecture. The tutorial covers domain modeling, navigation, state sharing, persistence, effects, and testing, starting with an overview of the SyncUps app and proceeding through building lists, forms, detail screens, and meeting recording features.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/01-WhatIsSyncUps · high confidence

A new tvOS case study has been added to the Examples directory, illustrating how to programmatically control focus in a tvOS application using the Composable Architecture. The example features a root view that scopes a focus reducer, allowing the UI to react to state changes via the \.onChange\ modifier and \resetFocus\ environment value to update the active focus among a grid of buttons.

Examples/CaseStudies/tvOSCaseStudies · high confidence

This change introduces a new set of SwiftUI view modifiers and binding helpers in the \Sources/ComposableArchitecture/Observation\ directory to support the library's new \ObservableState\-based store architecture. Specifically, it adds \alert\ and \confirmationDialog\ view extensions that present alerts and confirmation dialogs based on optional store state, provides \scope\ operators on \Binding\, \ObservedObject.Wrapper\, \SwiftUI.Bindable\, and \UIBindable\ to derive bindings for navigation stacks (\StackState\), and implements \\_StoreCollection\ to enable efficient scoping of identified arrays for use with \ForEach\. These additions allow developers to bind their Composable Architecture stores directly to SwiftUI's native observation and binding systems, replacing the previous Perception-based tracking mechanisms for these specific UI interactions.

Sources/ComposableArchitecture/Observation · high confidence

The "Record meeting" chapter of the Building SyncUps tutorial now includes the implementation for the meeting timer. The \RecordMeeting\ reducer handles a \timerTick\ action to increment the elapsed time and rotate the speaker index based on the configured duration per attendee. When the meeting duration is reached, the tutorial code demonstrates inserting the new meeting into the shared \syncUp\ state and using the \dismiss\ dependency to close the view.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/08-RecordMeeting · high confidence

The "Building SyncUps" tutorial's "Navigating to sync-up detail" and "Navigating to a meeting" chapters now demonstrate how to integrate a \NavigationStack\ into the app. This includes creating an \AppFeature\ reducer with a \Path\ enum to manage navigation destinations, wiring up the \SyncUpsListView\ and \SyncUpDetailView\ within the stack, and adding a new \MeetingView\ to display past meeting transcripts and attendees. The tutorial also provides updated code examples and tests for these navigation flows.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/07-SyncUpDetailNavigation · high confidence

The MotionManager example project has been deleted from the repository. This removes the Xcode project file and associated source files (including the app target, test target, and ComposableArchitecture dependencies) that previously demonstrated motion management capabilities.

Examples/MotionManager/MotionManager.xcodeproj · high confidence

The \ComposableArchitectureTestSupport\ module, which previously provided the \TestStore\ class and \Reducer\ extensions for unit testing reducers, has been removed from the codebase. Users can no longer import this support library to assert against reducer behavior or scope test stores.

Sources/ComposableArchitectureTestSupport · high confidence

The \AnyScheduler\ and \TestScheduler\ types, along with their associated convenience extensions and typealiases, have been removed from the Composable Architecture scheduling module. Users can no longer use these built-in schedulers for type-erasure or deterministic testing within this library; instead, the project now relies on the external \combine-schedulers\ package for these capabilities.

Sources/ComposableArchitecture/Scheduling · high confidence

The \ActivityIndicator\ SwiftUI wrapper and the \AlertData\ model have been removed from the Common module. This cleanup eliminates custom UI components and data structures that are no longer used, simplifying the codebase by relying on standard SwiftUI features or other shared implementations.

Examples/TicTacToe/Sources/Common · high confidence

The legacy MotionClient implementation, including its live and mock providers along with the DeviceMotion model, has been removed from the MotionManager example. This change eliminates the previous abstraction layer for CoreMotion, indicating a shift in how motion data is handled within the application's architecture.

Examples/MotionManager/MotionManager/MotionClient · high confidence

The \Reducer.debug\ and \Reducer.debugActions\ methods, along with the \DebugEnvironment\ struct, have been removed from the \Sources/ComposableArchitecture/Debugging\ module. This change eliminates the previous mechanism for printing debug messages describing received actions and state mutations in DEBUG builds, requiring users to adopt the library's updated debugging approach.

Sources/ComposableArchitecture/Debugging · high confidence

The SwiftUI view implementations for the Tic-Tac-Toe example's login, new-game, and two-factor flows have been deleted. This removes the user-facing UI components that previously handled email/password entry, player name configuration, and two-factor code submission within the SwiftUI layer of the example app.

Examples/TicTacToe/Sources/Views-SwiftUI · high confidence

The core implementation files for the Tic Tac Toe example have been deleted, including the app state and reducer (AppCore), authentication client definitions (AuthenticationClient, LiveAuthenticationClient), and the feature reducers for login (LoginCore), new game (NewGameCore), and two-factor authentication (TwoFactorCore). This removes the local logic for handling user authentication flows, game state management, and the associated environment configurations from this directory.

Examples/TicTacToe/Sources/Core · high confidence

The \DownloadClient.swift\ and \DownloadComponent.swift\ files in the Higher-Order Reducers case study have been deleted. This removes the legacy implementation of the reusable offline download component, which previously relied on \Combine\ and older \ComposableArchitecture\ APIs like \Effect.async\ and \WithViewStore\.

Examples/CaseStudies/SwiftUICaseStudies/04-HigherOrderReducers-ResuableOfflineDownloads · high confidence

The UIKit-specific view controllers (GameViewController, LoginViewController, NewGameViewController, and TwoFactorViewController) have been deleted from the TicTacToe example. This removes the UIKit implementation layer from this location, indicating a shift away from UIKit for this demo.

Examples/TicTacToe/Sources/Views-UIKit · high confidence

A change to existing behaviour in Sources/ComposableArchitecture/Documentation.docc/Resources — 4 commits (1 fix), 16 files.

Sources/ComposableArchitecture/Documentation.docc/Resources · medium confidence · unverified

The ComposableArchitecture library now includes a PrivacyInfo.xcprivacy file to comply with Apple's App Privacy Manifest requirements. This manifest declares that the library accesses the NSPrivacyAccessedAPICategoryUserDefaults API (reason code C56D.1) and explicitly states that no user data is collected or tracked.

Sources/ComposableArchitecture/Resources · high confidence

The Voice Memos demo's audio recording client has been updated to use modern Swift concurrency patterns. The client's methods (currentTime, requestRecordPermission, startRecording, stopRecording) now return async values instead of Composable Architecture Effects, and the implementation uses an actor to manage the underlying AVAudioRecorder state. This change simplifies the code by removing manual effect handling and dependency keys in favor of native async/await, while also updating the live implementation to use the new Dependencies library conventions.

Examples/VoiceMemos/VoiceMemos/AudioRecorderClient · high confidence

The Case Studies Xcode project has been updated to object version 54 and restructured to reflect the latest architecture. The project now uses a unified app entry point (CaseStudiesApp) and RootView instead of separate UIKit scene delegates, and it no longer embeds the ComposableArchitecture frameworks directly in the build phases. The case studies themselves have been renumbered and reorganized into clearer categories (e.g., GettingStarted, Effects, Navigation, HigherOrderReducers), with new examples added for features like FocusState, Animations, Alerts, Shared State (UserDefaults, InMemory, FileStorage, Onboarding), Refreshable effects, WebSocket effects, and multiple navigation destinations, while older or redundant examples have been removed.

Examples/CaseStudies/CaseStudies.xcodeproj · high confidence

The ComposableArchitecture library has been updated to version 2, introducing a significant behavioral and architectural shift. The core \Reducer\ protocol is now a protocol with an associated \Body\ type, replacing the previous function-based signature, and the \Effect\ type has been simplified to \Effect\<Action\>\ with a new \.run\ operation for async work, removing the old Combine-based publisher wrapper. A new \@Reducer\ macro automates reducer conformance and supports enum-based scoping via the new \CaseReducer\ protocol and \@ReducerCaseEphemeral\/\@ReducerCaseIgnored\ macros. The \Store\ is now \@MainActor\ isolated and uses the \Observable\ framework for state observation instead of \ObservableObject\. Additionally, the library no longer vendors \CasePaths\; it now depends on the external \swift-case-paths\ package, and \TestStore\ has been redesigned to work with the new macro-based reducers and exhaustive testing model.

Sources/ComposableArchitecture · high confidence

The \AppStorageKeyPathKey\ type and its associated \SharedReaderKey.appStorage(\_:)\ factory method are now deprecated in favor of using \AppStorageKey\. This change affects how users share data via UserDefaults using key paths; while the existing implementation remains functional for both Sharing 2.0 and earlier versions, users should migrate to the recommended \AppStorageKey\ approach to avoid deprecation warnings.

Sources/ComposableArchitecture/Sharing · high confidence

The \Effects\ module has been refactored to replace the previous Combine-based cancellation and debouncing mechanisms with native Swift Concurrency primitives. \Effect.cancellable\ now requires \Sendable\ identifiers and utilizes \withTaskCancellation\ for \.run\ effects, while \.publisher\ effects are handled via \PrefixUntilOutput\ publishers. The dedicated \Effect.debounce\ and \Effect.timer\ helpers have been removed, shifting users toward standard scheduler or clock-based timing. This change improves thread safety and aligns the library's cancellation model with modern Swift async/await patterns.

Sources/ComposableArchitecture/Effects · high confidence

The internal implementation of the Composable Architecture has been refactored to improve thread safety and modernize its dependency stack. A new \CurrentValueRelay\ class has been introduced to replace previous Combine-based relay patterns, providing a lock-protected mechanism for broadcasting current values to subscribers. The \DemandBuffer\ used in publisher creation has been updated to use \NSRecursiveLock\ instead of manual \os\_unfair\_lock\ memory management, and the internal \Publishers.Create\ and \Effect.Subscriber\ types have been marked \Sendable\ to support Swift concurrency. Additionally, the library now explicitly exports a suite of external dependencies—including \CasePaths\, \Clocks\, \CombineSchedulers\, \ConcurrencyExtras\, \CustomDump\, \Dependencies\, \DependenciesMacros\, \IdentifiedCollections\, \Observation\, \Perception\, \Sharing\, \SwiftUINavigation\, and \UIKitNavigation\—via the \Exports.swift\ module, consolidating the public API surface.

Sources/ComposableArchitecture/Internal · high confidence

The internal utilities for the case studies have been updated to align with modern SwiftUI patterns and fix specific UI issues. A new \AboutView\ now collapses case study documentation behind a disclosure group, and a \ResignFirstResponder\ binding extension was added to work around a SwiftUI bug where disabling a focused text field causes console errors. Several legacy helpers were removed, including \ActivityIndicator\ and \IfLetSubscript\, while \CircularProgressView\ was updated to use the new \animation(\_:value:)\ modifier and the new \\#Preview\ macro. Additionally, \TemplateText\ now uses \Text(verbatim:)\ to suppress localization warnings, and \UIViewRepresented\ was simplified by moving the \UIView\ constraint to the generic type parameter.

Examples/CaseStudies/SwiftUICaseStudies/Internal · high confidence

The Tic-Tac-Toe example has been updated to use the modern Composable Architecture patterns, introducing new SwiftUI views for login, two-factor authentication, and game creation. These views utilize \@ViewAction\ and \@Bindable\ for state management, implement proper navigation stacks for multi-step flows, and include preview support for rapid UI development.

Examples/TicTacToe/tic-tac-toe/Sources/LoginSwiftUI · high confidence

The UIKit integration has been updated to use the new \NavigationStackController\ and \UIAlertController\ initializers that accept stores directly, replacing the previous \ifLet\-based optional state subscription pattern which has been removed. This change simplifies presenting alerts and managing navigation stacks by leveraging \UIBinding\ and \UIPushAction\ helpers, aligning UIKit usage with the library's modern navigation and state-scoping conventions.

Sources/ComposableArchitecture/UIKit · high confidence

The tutorial code for the Contacts feature has been updated to consolidate multiple optional presentation states (add contact sheet and delete alert) into a single \Destination\ enum. This change replaces separate \@Presents\ properties and \PresentationAction\ cases with a unified \destination\ state and action, ensuring that only one destination can be active at a time and reducing the risk of invalid states.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/02-Navigation/02-MultipleDestinations · high confidence

The offline download case study has been updated to run in Swift 6 mode, including dropping support for Swift versions prior to 5.9 and adopting the \any\ existential syntax for protocols. The implementation has been refactored to use the Composable Architecture's newer APIs, such as \@Reducer\, \@ObservableState\, and \StoreOf\, replacing the previous Combine-based and older TCA patterns. A new \DownloadClient\ dependency has been introduced to handle network requests, and the UI components have been updated to use \@Bindable\ and modern view modifiers, ensuring the example demonstrates current best practices for building offline-capable features.

Examples/CaseStudies/SwiftUICaseStudies/05-HigherOrderReducers-ResuableOfflineDownloads · high confidence

The UIKit-based demo application for the MotionManager has been removed. This change deletes the LaunchScreen storyboard, Info.plist, SceneDelegate, and the original MotionManagerView, eliminating the need for manual scene management and legacy launch screens. The example now relies on SwiftUI lifecycle management, simplifying the demo structure and aligning it with modern Apple platform development practices.

Examples/MotionManager/MotionManager · high confidence

The Search example has been updated to use the latest Composable Architecture patterns and modern Swift features. The app now uses the \@main\ App lifecycle instead of a SceneDelegate, and the feature domain is defined using the \@Reducer\ and \@ObservableState\ macros. Network calls have been migrated from Combine-based \Effect\s to async/await functions via the \@DependencyClient\ macro, simplifying the concurrency model. The underlying weather service has switched from Metaweather to Open-Meteo, updating the data models and API endpoints accordingly. Additionally, the custom \ActivityIndicator\ UIViewRepresentable has been removed in favor of native SwiftUI solutions.

Examples/Search/Search · high confidence

The Search example project has been updated to use the App lifecycle (replacing SceneDelegate.swift with SearchApp.swift) and removed the manual embedding of the ComposableArchitecture and ComposableArchitectureTestSupport frameworks in favor of package product dependencies. The project file also reflects an upgrade to Xcode 16 (objectVersion 54, LastUpgradeCheck 1600), enables parallel independent target builds, adds stricter compiler warnings, and includes a README.md file.

Examples/Search/Search.xcodeproj · high confidence

The Speech Recognition example has been updated to use the Composable Architecture 1.0 API, replacing the previous Combine-based reducer pattern with the new \@Reducer\ and \@ObservableState\ macros. The app entry point now uses the \@main\ \App\ protocol instead of the deprecated \SceneDelegate\ and \AppDelegate\, and the speech recognition logic has been refactored to use async/await effects (\Effect.run\) instead of Combine publishers, simplifying the handling of authorization and live transcription tasks.

Examples/SpeechRecognition/SpeechRecognition · high confidence

The SpeechRecognition example's client layer has been migrated from a Combine-based Effect system to Swift's native async/await concurrency model. The \SpeechClient\ now exposes \startTask\ as an \AsyncThrowingStream\ and \requestAuthorization\ as a simple async function, replacing the previous \recognitionTask\ and \cancelTask\ methods. This change is accompanied by a cleanup of the \SpeechRecognitionResult\ and \Transcription\ data models, which now align more closely with the underlying Speech framework by removing deprecated fields (such as \averagePauseDuration\ from \Transcription\) and adding support for \SpeechRecognitionMetadata\. Additionally, the client now utilizes the \@DependencyClient\ macro for dependency injection, simplifying testing and preview support.

Examples/SpeechRecognition/SpeechRecognition/SpeechClient · high confidence

The SpeechRecognition example project has been updated to support Xcode 16 (project format 54) and migrated from the UIKit SceneDelegate pattern to the SwiftUI App lifecycle (SpeechRecognitionApp.swift). The project structure was cleaned up by removing the now-unnecessary ComposableArchitectureTestSupport dependency and its associated build phases, while adding a README.md to the project group. Additionally, stricter compiler warnings were enabled, including quoted-include-in-framework-header checks and user script sandboxing.

Examples/SpeechRecognition/SpeechRecognition.xcodeproj · high confidence

The library now requires iOS 16, macOS 13, tvOS 16, and watchOS 9, and adds a dedicated Swift 6.1 package manifest to enable Swift 6 language mode and concurrency features. It also introduces two new package traits, ComposableArchitecture2Deprecations and ComposableArchitecture2DeprecationOverloads, to help users prepare for the next major release by enabling viral deprecations and overload-based migrations.

(repo-wide) · high confidence

The SwiftUI Case Studies have been overhauled to demonstrate the new Composable Architecture (TCA2) patterns. Key changes include the adoption of the \@Reducer\ and \@ObservableState\ macros, the use of \@Presents\ for managing alerts and navigation destinations, and the introduction of \@Shared\ for cross-screen state synchronization (demonstrated in the new Shared State case studies for In-Memory, UserDefaults, and File Storage). The examples now utilize \BindingReducer\ and \BindingAction\ for form bindings, \Store(initialState:reducer:)\ for store initialization, and modern SwiftUI APIs like \NavigationStack\ and \@Bindable\. Legacy patterns such as \ViewStore\, \WithViewStore\, and old alert APIs have been replaced with the new presentation and binding systems.

Examples/CaseStudies/SwiftUICaseStudies · high confidence

The SwiftUI integration has been completely overhauled to support Swift 6 concurrency and modern SwiftUI APIs. The library now introduces \BindingAction\ and \BindableAction\ to provide a safer, type-safe mechanism for handling state mutations via key paths, replacing older binding patterns. Concurrently, legacy components such as \ViewStore\, \WithViewStore\, \ForEachStore\, \IfLetStore\, \Identified\, and \IdentifiedArray\ have been removed from this module, indicating a shift toward new abstractions or external dependencies for these capabilities.

Sources/ComposableArchitecture/SwiftUI · high confidence

The Standups example has been renamed to SyncUps, with the Xcode project and scheme migrated from the previous TicTacToe template. The project now targets Xcode 16 (version 1.7 scheme) and includes a dedicated test plan (SyncUps.xctestplan) for running unit and UI tests, while updating build references to point to the new SyncUps.app and SyncUpsTests.xctest targets.

Examples/SyncUps/SyncUps.xcodeproj · high confidence

The 'Lists of SyncUps' tutorial code has been updated to use \IdentifiedArrayOf\ from the \IdentifiedCollections\ library for the \attendees\ and \meetings\ properties, replacing plain arrays to encourage ID-based element access. The tutorial also adds a \TrailingIconLabelStyle\ for improved list row icons, updates the \CardView\ to use \foregroundStyle\, and includes new test scaffolding using Swift Testing to verify the deletion of sync-ups via \TestStore\.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/02-ListsOfSyncUps · high confidence

The Tic Tac Toe example project has been reorganized into a new package structure, resulting in the removal of several individual Xcode schemes (AppSwiftUI, AuthenticationClient, LiveAuthenticationClient, NewGameSwiftUI, TicTacToeCommon, TwoFactorCore, and TwoFactorSwiftUI). The main TicTacToe scheme has been updated to target Xcode 16 (LastUpgradeVersion 1600) and its test configuration now references test bundles from the new 'tic-tac-toe' container rather than the previous 'TicTacToe.xcodeproj'.

Examples/TicTacToe/TicTacToe.xcodeproj/xcshareddata · high confidence

The Tic-Tac-Toe UIKit demo has been refactored to use the modern Composable Architecture patterns, replacing the legacy \Store\<AppState, AppAction\>\ with \StoreOf\<TicTacToe\>\ and removing Combine-based state scoping. The \AppViewController\ now uses the \observe\ API to handle the \TicTacToe\ enum's \.login\ and \.newGame\ cases, simplifying the navigation logic and aligning the example with the latest \@Reducer\ and Observable architecture standards.

Examples/TicTacToe/tic-tac-toe/Sources/AppUIKit · high confidence

The Tic-Tac-Toe SwiftUI demo has been refactored to use the latest Composable Architecture conventions. The view now uses \StoreOf\<Game\>\ instead of a generic \Store\, accesses state properties directly (e.g., \store.title\) rather than through a separate \ViewState\ struct, and utilizes the new \Store.init\ reducer builder syntax. Additionally, the preview environment has been updated to use \NavigationStack\ and the modern \\#Preview\ macro.

Examples/TicTacToe/tic-tac-toe/Sources/GameSwiftUI · high confidence

The Tic-Tac-Toe example has been restructured to use the \StoreOf\ type instead of the generic \Store\ and replaces the legacy \NavigationView\ with \NavigationStack\. The view body now uses a \switch\ statement on the store's case to handle navigation states, removing the previous \IfLetStore\ scoping and explicit \StackNavigationViewStyle\ configuration.

Examples/TicTacToe/tic-tac-toe/Sources/AppSwiftUI · high confidence

The Tic-Tac-Toe example app has been updated to use the modern iOS 13+ scene-based lifecycle. The traditional Info.plist and SceneDelegate.swift files have been removed, indicating a migration to the newer application lifecycle model. Additionally, the README has been updated to reflect the current location of the Square Workflows Tic-Tac-Toe sample.

Examples/TicTacToe · high confidence

The Tic-Tac-Toe example app has been updated to reflect modern SwiftUI and ComposableArchitecture patterns. The app entry point now uses the standard @main App struct, and the root view has migrated from the deprecated NavigationView to NavigationStack, utilizing the new navigationTitle modifier. Internally, the Store initialization has been simplified to use the new builder-based initializer, and the preview provider has been updated to the modern \#Preview macro. Additionally, the app now imports AppUIKit and AuthenticationClientLive, indicating support for both SwiftUI and UIKit implementations within the same example.

Examples/TicTacToe/App · high confidence

The Tic-Tac-Toe example application has been refactored to adopt a modern architecture, replacing the previous UIKit-based implementation (which relied on multiple separate frameworks like AppCore, LoginSwiftUI, and GameCore) with a streamlined SwiftUI approach. The project now uses a single \TicTacToeApp.swift\ entry point instead of a SceneDelegate, and the build configuration has been updated to Xcode 15 standards (project file object version 54). This change simplifies the project structure by removing numerous intermediate framework dependencies and legacy view controllers, resulting in a cleaner, more maintainable example that demonstrates current Apple platform best practices.

Examples/TicTacToe/TicTacToe.xcodeproj · high confidence

The Tic-Tac-Toe example has been updated to use the Composable Architecture 1.0, replacing the previous reducer-based implementation with the new \@Reducer\ and \@ObservableState\ macros. The game state is now defined within a \Game\ struct, and the board representation has changed from a nested array (\\[\[Player?\]\]\) to a custom \Three\<Element\>\ collection type. This change aligns the example with the latest concurrency and state-management patterns in the library.

Examples/TicTacToe/tic-tac-toe/Sources/GameCore · high confidence

The Todos example app has been updated to use the Composable Architecture 1.0 API, replacing the previous manual reducer and view store patterns with modern \@Reducer\, \@ObservableState\, and \@Dependency\ macros. This change simplifies the codebase by using \BindingReducer\ for state binding, \IdentifiedArrayOf\ for managing the list of todos, and \EffectTask\-based concurrency for asynchronous operations like debouncing sort actions. The app entry point now uses a static store declaration, and the scene lifecycle has been simplified by removing the manual \SceneDelegate\ in favor of SwiftUI's \@main\ app lifecycle.

Examples/Todos/Todos · high confidence

The Todos example project has been updated to Xcode 16 (objectVersion 54) with a deployment target bump to iOS 16. The app entry point has shifted from SceneDelegate.swift to a SwiftUI App lifecycle (TodosApp.swift), and the project structure was cleaned up by removing the ComposableArchitectureTestSupport dependency, the Frameworks group, and the Info.plist reference. Additionally, new build settings were enabled for Swift asset symbol extensions, quoted framework header warnings, and user script sandboxing, while parallel independent target building was activated.

Examples/Todos/Todos.xcodeproj · high confidence

The 'Your First Presentation' tutorial code samples now demonstrate using a delegate action pattern for the AddContactFeature to communicate results (save or cancel) back to the parent ContactsFeature, replacing the previous approach of handling child actions directly via PresentationAction. The AddContactFeature reducer now includes a Delegate enum and sends delegate actions, while the parent ContactsFeature handles these delegate actions to update state and dismiss the sheet, with the dismiss logic implemented using the @Dependency(\\.dismiss) property wrapper and async effects.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/02-Navigation/01-YourFirstPresentation · high confidence

The UIKit case studies (Counter, Lists, Navigate and Load, etc.) have been updated to use the new @Reducer and @ObservableState macros, replacing the previous Reducer protocol and ViewStore pattern. This change removes Combine dependencies from the examples, simplifies state management by using direct store observation via the observe() helper, and updates UI elements to use system colors for proper light/dark mode support. The entry points (AppDelegate and SceneDelegate) are also modernized to use the @main entry point and final classes.

Examples/CaseStudies/UIKitCaseStudies · high confidence

The UIKit case study examples have been refined for better usability and code quality. Background colors in the ActivityIndicatorViewController now use system colors to properly support light and dark modes. The internal UIViewRepresented helper has been removed as it is no longer needed. Additionally, the IfLetStoreController has been modernized by making its properties private, simplifying its initializer signature, and updating the code to use Swift's latest guard-let syntax.

Examples/CaseStudies/UIKitCaseStudies/Internal · high confidence

The LoginUIKit and TwoFactorUIKit demo views have been rewritten to use the Composable Architecture's \@ViewAction\ and \@UIBindable\ macros. This updates the UIKit implementations to leverage the new observable architecture, simplifying state binding and action dispatching for the login and two-factor authentication flows.

Examples/TicTacToe/tic-tac-toe/Sources/LoginUIKit · high confidence

The ComposableArchitecture workspace configuration has been updated to include the new SyncUps example project and replace the MotionManager example with the Integration example. This ensures that the SyncUps app is available for users to explore and that the workspace references the correct set of example projects.

ComposableArchitecture.xcworkspace · high confidence

The 'Adding Side Effects' tutorial code samples have been updated to demonstrate fetching data from the number-trivia.com API instead of the obsolete numbersapi.com. The examples now show how to perform asynchronous network requests using Swift's \async/await\ within \.run\ effects, properly handling state updates by sending a \factResponse\ action back to the reducer, and managing a repeating timer with cancellation support.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/01-Essentials/02-AddingSideEffects · high confidence

The 'Your First Feature' tutorial code samples have been updated to reflect the Composable Architecture 1.0 API. Reducers are now defined using the \@Reducer\ macro instead of manual protocol conformance, and state structs are annotated with \@ObservableState\ to enable SwiftUI observation. The tutorial also demonstrates creating a \Store\ with a trailing closure for the reducer and using \StoreOf\ in views.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/01-Essentials/01-YourFirstFeature · high confidence

The 'Composing Features' tutorial in the Composable Architecture documentation has been updated to demonstrate best practices for feature composition. The example now shows how to combine multiple \CounterFeature\ reducers into a single \AppFeature\ using the \Scope\ reducer, rather than managing isolated stores for each tab. Consequently, the \AppView\ now derives child stores for each tab using the \store.scope\ operator from a single root \StoreOf\<AppFeature\>\, and the app entry point initializes this single composed store. The tutorial also includes updated test scaffolding using Swift Testing and \TestStore\ to verify the composed feature's behavior.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/01-Essentials/04-ComposingFeatures · high confidence

The code examples in the SyncUpDetail tutorial have been updated to reflect current best practices. The view now uses the @Bindable property wrapper for store access instead of the let store pattern. The editing flow has been refactored to use the @Presents property wrapper for the editSyncUp state and the .sheet(item:) modifier for presentation, replacing the older .ifLet reducer pattern. Additionally, the delete confirmation alert now uses the AlertState builder syntax and the deletion logic has been updated to use @Shared for state management and .run for the dismiss effect.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/06-SyncUpDetail · high confidence

The 'Presenting Sync-up Form' tutorial chapter has been updated to show how to integrate the child \SyncUpForm\ feature into the parent \SyncUpsList\ reducer using the \@Presents\ macro, \PresentationAction\, and the \ifLet\ reducer operator. The view layer examples now use \@Bindable\ and \Binding.scope\ to drive a SwiftUI sheet, and include toolbar actions for confirming or discarding the new sync-up. Additionally, the testing examples have been refined to use the \uuid\ dependency with an incrementing mock to ensure deterministic test assertions when creating new sync-ups.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/04-PresentingSyncUpForm · high confidence

The 'Persisting SyncUps' tutorial code examples have been updated to demonstrate persisting state to disk using the \@Shared\ property wrapper with the \fileStorage\ strategy. The \SyncUpsList\ reducer now declares \syncUps\ as \@Shared(.syncUps)\ instead of a local state property, requiring mutations to use the \withLock\ method on the projected value. The tutorial also introduces type-safe keys for the persistence URL and updates the app entry point and test cases to correctly initialize and interact with the shared, persisted state.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/05-PersistingSyncUps · high confidence

The Xcode project schemes for the CaseStudies example (including tvOS, SwiftUI, and UIKit targets) have been upgraded to Xcode version 1600. This change updates the internal scheme configuration files to reflect the newer Xcode toolchain, ensuring compatibility with recent development environments.

Examples/CaseStudies/CaseStudies.xcodeproj/xcshareddata · high confidence

The Xcode workspace schemes have been upgraded to Xcode 16 (version 1600) and reorganized. The main library scheme now includes code coverage support and adds the ComposableArchitectureMacrosTests target to its test suite, while also injecting a CI environment variable. The benchmark scheme has been renamed from GameSwiftUI to swift-composable-architecture-benchmark, updated to target the new benchmark build product, and switched its launch configuration from Debug to Release.

ComposableArchitecture.xcworkspace/xcshareddata/xcschemes · high confidence

The Xcode scheme for the Integration example has been updated to target Xcode 16 (version 1600) and now launches the Integration.app instead of the previous LoginSwiftUI framework. The scheme's test configuration has also been adjusted to run IntegrationUITests, reflecting the project's reorganization from the TicTacToe example.

Examples/Integration/Integration.xcodeproj/xcshareddata · high confidence

The Xcode scheme for the VoiceMemos example has been updated to target the VoiceMemos application bundle instead of the previous AppCore framework, ensuring that running, profiling, and testing actions correctly launch the app. The scheme's last upgrade version is set to 1600, and the testable reference now points to VoiceMemosTests.

Examples/VoiceMemos/VoiceMemos.xcodeproj/xcshareddata · high confidence

The Xcode scheme files for the Search, SpeechRecognition, and Todos example projects have been updated to set the LastUpgradeVersion to 1600, aligning them with Xcode 16.

Examples/Search/Search.xcodeproj/xcshareddata, Examples/SpeechRecognition/SpeechRecognition.xcodeproj/xcshareddata, Examples/Todos/Todos.xcodeproj/xcshareddata · high confidence

The Meet The Composable Architecture tutorial for NavigationStacks has been updated to demonstrate modern stack navigation patterns. The sample code now uses \StackState\ and \StackAction\ to manage a navigation stack of \ContactDetailFeature\ instances within \ContactsFeature\, replacing previous approaches. The \ContactsView\ now utilizes the \NavigationStack(path:root:destination:)\ initializer and \NavigationLink(state:)\ to drive navigation from the store. Additionally, the deletion flow has been refactored so that the \ContactDetailFeature\ handles the confirmation alert and sends a delegate action to the parent \ContactsFeature\ to remove the contact from the list, rather than handling deletion directly in the list feature.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/02-Navigation/04-NavigationStacks · high confidence

The 'Testing your features' tutorial code samples have been updated to use the Swift Testing framework (import Testing, @Test, @MainActor) instead of XCTest, and the CounterFeature reducer now requires its State to conform to Equatable. The tutorial also demonstrates testing asynchronous effects using the TestStore's receive method with timeouts, and shows how to test dependencies by injecting a mock NumberFactClient via the TestStore's withDependencies closure.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/01-Essentials/03-TestingYourFeatures · high confidence

The Voice Memos example has been refactored to adopt the modern Composable Architecture patterns, replacing the legacy \Reducer\ and \Environment\ structs with \@Reducer\, \@ObservableState\, and \@Dependency\ property wrappers. The app now uses Swift Concurrency (\async/await\) for audio recording and playback, replacing the previous \Effect\-based timer and player logic. The \SceneDelegate\ and \AppDelegate\ have been removed in favor of a SwiftUI \@main\ app entry point, and dependency injection for audio clients and system services (like opening settings) is now handled via the \Dependencies\ library.

Examples/VoiceMemos/VoiceMemos · high confidence

The VoiceMemos example project has been updated to target the latest Xcode and iOS versions, removing the deprecated SceneDelegate in favor of the iOS 15+ App lifecycle (VoiceMemosApp.swift). The project structure has been reorganized to include new helper files (Helpers.swift, RecordingMemo.swift, VoiceMemo.swift) and a README, while removing mock client implementations (MockAudioPlayerClient, MockAudioRecorderClient) and the ComposableArchitectureTestSupport dependency from the main app target. These changes reflect a shift towards modern Swift concurrency patterns and simplified project configuration.

Examples/VoiceMemos/VoiceMemos.xcodeproj · high confidence

The 'Sync-up form' tutorial chapter has been updated with corrected code examples. The view implementation now demonstrates managing keyboard focus using \@FocusState\ and the \.focused\ modifier, including logic to automatically focus the title field on appearance and the newly added attendee on insertion. The reducer logic has been refactored to manage the \focus\ state directly, allowing focus changes to be tested alongside business logic. Additionally, new Swift Testing examples have been added to verify attendee removal and focus state transitions.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/03-SyncUpForm · high confidence

The 'Testing Presentation' section of the Meet the Composable Architecture tutorial has been updated to demonstrate testing navigation flows using the Swift Testing framework. The examples now show how to inject a controlled UUID dependency into the TestStore to ensure deterministic state assertions, and they utilize the @CasePathable macro to enable concise key-path-based action sending and state mutation checks.

Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/02-Navigation/03-TestingPresentation · high confidence

Add internal test infrastructure for integration UI tests; Added Swift Testing suite for Tic-Tac-Toe example app; Added UI test for the sync-up creation flow; Added UI tests for Observable Architecture on iOS 17 and legacy integration tests on iOS 16; Added UI tests for enum-based feature toggles and store lifecycle; Added UI tests for iOS 16+17 integration scenarios; Added comprehensive test coverage for Composable Architecture core features; Added focus behavior tests for tvOS case studies; Added integration UI tests for legacy store patterns and presentation behaviors; Added internal test infrastructure and removed obsolete throttle tests; Added macro expansion and diagnostic tests for ComposableArchitecture macros; Added tests for TwoFactorCore authentication flow; Added tests for the Tic Tac Toe login core; Added unit tests for Composable Architecture reducers; Integration test suite project structure; Migrate SpeechRecognition tests to Swift Testing; Migrate Todos example tests to Swift Testing; Migrate UIKit case study tests to Swift Testing; Migrated Search tests to Swift Testing; Removed MotionManager example tests; Removed Tic Tac Toe test suite; SwiftUICaseStudies tests migrated to Swift Testing.

The library has been upgraded to Swift 6.1 and requires a minimum deployment of iOS 16, macOS 13, tvOS 16, and watchOS 9. This change introduces a comprehensive dependency update, including swift-dependencies 1.4.0+, swift-navigation 2.7.0+, swift-perception 2.0+, and swift-sharing 2.0+, alongside the addition of new dependencies like swift-issue-reporting and swift-clocks. The package now utilizes SPM traits for deprecation management and includes a new macro target for ComposableArchitectureMacros.

(dependencies) · high confidence

A new benchmark suite has been added to measure the performance of the Composable Architecture's store scoping, state access, and action sending capabilities. The benchmarks specifically evaluate both flat and deeply nested (10 levels) store hierarchies, providing data on the overhead of creating scoped stores, sending actions, and accessing state in these scenarios.

Benchmarks · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 42 → 57 (+14.3)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 90 (-9.7)
• Architecture 98 (new)
• Maturity 65 → 72 (+7.2)
• Readiness 28 → 58 (+30.6)
• Security 39 → 42 (+2.5)

• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No automated tests
• No exposed public API
• No tests found
• Test reliability not included
• The Examples directory is a single workspace (ComposableArchitecture.xcworkspace), so readers cannot browse individual case studies independently of one another without opening the workspace. (Examples/README.md)

• Change coupling: Package.swift ↔ Exports.swift (Package.swift)
• Coverage not measured — Swift suite
• Documentation: hard to navigate (Sources/ComposableArchitecture/Documentation.docc/Articles/WhatIsNavigation.md)
• Duplicated block (10 lines × 11) (Examples/SyncUps/SyncUps/SyncUpDetail.swift)
• Duplicated block (10 lines × 15) (Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/08-RecordMeeting/ImplementingTimer-01-code-0009.swift)
• Duplicated block (10 lines × 2) (Examples/CaseStudies/UIKitCaseStudies/LoadThenNavigate.swift)
• Duplicated block (10 lines × 2) (Examples/SpeechRecognition/SpeechRecognition/SpeechClient/Live.swift)
• Duplicated block (10 lines × 2) (Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/01-Essentials/03-TestingYourFeatures/01-03-02-code-0002.swift)
• Duplicated block (10 lines × 2) (Sources/ComposableArchitecture/Documentation.docc/Tutorials/MeetTheComposableArchitecture/01-Essentials/03-TestingYourFeatures/01-03-03-code-0002.swift)
• Duplicated block (10 lines × 2) (Sources/ComposableArchitecture/Internal/Deprecations.swift)
• Duplicated block (10 lines × 2) (Sources/ComposableArchitecture/Internal/Deprecations.swift)
• Duplicated block (10 lines × 2) (Sources/ComposableArchitecture/TestStore.swift)
• Duplicated block (10 lines × 3) (Examples/CaseStudies/UIKitCaseStudies/CounterViewController.swift)
• Duplicated block (10 lines × 3) (Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/04-PresentingSyncUpForm/TestingSyncUpFormPresentation-02-code-0004.swift)
• Duplicated block (10 lines × 4) (Sources/ComposableArchitecture/Observation/Store+Observation.swift)
• Duplicated block (10 lines × 6) (Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/06-SyncUpDetail/EditingAndDeletingSyncUp-02-code-0013.swift)
• Duplicated block (10 lines × 7) (Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/07-SyncUpDetailNavigation/MeetingNavigation-02-code-0003-previous.swift)
• Duplicated block (10–11 lines × 9) (Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/08-RecordMeeting/ImplementingTimer-04-code-0009.swift)
• Duplicated block (11 lines × 11) (Sources/ComposableArchitecture/Documentation.docc/Tutorials/BuildingSyncUps/04-PresentingSyncUpForm/TestingSyncUpFormPresentation-01-code-0008.swift)
• Duplicated block (11 lines × 16) (Examples/SyncUps/SyncUps/SyncUpDetail.swift)
• …and 501 more

• 1 commits — 1 feature/other, 0 fixes

• (root) — 1 commit

• change: Bump to IssueReporting 2.0 (#3948)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

pointfreeco/swift-composable-architecture was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.