DebugSwift/DebugSwift

DebugSwift is an iOS debugging toolkit that provides a comprehensive suite of runtime inspection and manipulation tools for developers. It enables real-time monitoring and analysis of network traffic, application performance metrics, UI layout, and system logs, while also offering capabilities to simulate events like push notifications and deep links. The system further facilitates data inspection and modification by providing browsers for local storage, databases, and keychain items, along with security auditing features.

45 changes.

This period focused on significantly expanding DebugSwift's capabilities with new modules for network inspection (including WebSocket and GraphQL), performance monitoring, and enhanced resource management. The project also modernized its infrastructure by migrating to Bazel, upgrading to Swift 6, and refactoring the core API to support instance-based configuration.

32 changes.

This period focused on significantly expanding DebugSwift's capabilities by adding new tools for database browsing, network simulation, UI layout inspection, and security auditing. Concurrently, the team implemented extensive unit test suites to ensure the reliability of these new features and existing components, while also improving build infrastructure for Apple Silicon support.

Users can now inspect and debug Core Data stacks at runtime via a new browser interface. This feature adds a \CoreDataBrowserViewController\ to list available managed object contexts and entities, a \CoreDataEntityViewController\ to view and search objects within an entity (with sorting and filtering), and a \CoreDataObjectDetailViewController\ to view individual object attributes and relationships. A \CoreDataManager\ singleton handles the configuration of persistent containers and contexts, as well as fetching, saving, and deleting objects, allowing developers to interact with their Core Data model directly within the DebugSwift tool.

DebugSwift/Sources/Features/Resources/CoreData · high confidence

A new Deep Link testing interface has been added to the DebugSwift app, allowing users to input and test custom URLs (both URL schemes and universal links) directly within the tool. The feature includes a text field for entering URLs, a 'Test Deep Link' button to trigger the link opening, and a 'Recent History' section that persists the last 50 test attempts in UserDefaults, displaying their status (Success, Failed, or Invalid) and type. Users can also clear the history or delete individual entries.

DebugSwift/Sources/Features/App/DeepLink · high confidence

A new Documentation Recorder feature has been added to DebugSwift, allowing users to capture annotated screenshots of app interactions (taps, scrolls, and text input) and save them as a sequence of steps. The tool provides a floating overlay control (SwiftUI on iOS 14+, fallback on earlier versions) to start, pause, and stop recordings, which are stored locally in the app's documents directory. Users can view their saved recordings in a list, inspect individual steps with annotated images, and export the sequence as images via the system share sheet or copy them to the clipboard.

DebugSwift/Sources/Features/Interface/DocRecorder · high confidence

Users can now view, search, and delete HTTP cookies stored by the system. This change introduces a new 'HTTP Cookies' section in the Resources view, powered by a dedicated ViewModel that lists cookies sorted by domain and name, supports case-insensitive filtering, and allows clearing all or individual cookies via the HTTPCookieStorage API.

DebugSwift/Sources/Features/Resources/HTTPCookies · high confidence

A new OSLog Console feature is available for iOS 15+ that allows users to view real-time system logs directly within the app. The console includes a toggle to start/stop capture, search functionality, and options to filter by subsystem (including Apple subsystems), clear logs, and export captured entries. The implementation uses a singleton monitor to poll OSLogStore and updates the UI via bindings.

DebugSwift/Sources/Features/App/OSLogConsole · high confidence

DebugSwift now includes a dedicated SwiftData browser (iOS 17+) that lets you view registered SwiftData contexts and their entities, search and filter model instances, inspect and edit property values, create new model records, and export entity data as JSON—all directly within the app.

DebugSwift/Sources/Features/App/SwiftData · high confidence

Users can now edit, duplicate, and delete individual items in the Resources Generic List via a long-press action sheet, and the list supports multi-selection editing mode. A new edit view controller allows modifying key-value pairs, with keys locked during edits to preserve identity. The controller exposes callbacks for data and edit-mode changes, enabling parent features to react to these updates.

DebugSwift/Sources/Features/Resources/GenericList · high confidence

Users can now view a history of past network sessions, including details like request counts and durations, and manage this history by clearing all sessions or deleting individual ones. Additionally, users can import requests from a saved session directly into the Response Modifier rules, replacing existing rules with those from the selected session.

DebugSwift/Sources/Features/Network/History · high confidence

New shell scripts (build\_xcframework.sh and build\_xcframework\_spm.sh) were added to the Scripts directory to automate the creation of the DebugSwift XCFramework. These scripts build the framework for iOS devices (arm64) and iOS simulators (including arm64 and x86\_64 architectures), enabling support for Apple Silicon Macs running iOS simulators. The process involves building separate frameworks for each platform and archiving them into a single XCFramework.

Scripts · high confidence

The Example/fastlane directory now includes a Fastfile and README that define a 'test' lane. This lane runs tests using the 'Example' scheme on the 'iPhone 17 Pro' device, with code coverage enabled and results bundled.

Example/fastlane · high confidence

Developers can now build the DebugSwift library using Bazel via the new BUILD.bazel file, and the project includes a generic Makefile to simplify building and running the Example app on the iOS Simulator. The repository also introduces a Dangerfile.swift to enforce pull request standards (such as size limits and description requirements) and a .swiftlint.yml configuration to standardize code style and analysis rules.

(repo-wide) · high confidence

The Files controller now allows users to browse App Group containers in addition to the standard App Sandbox. A segmented control in the header lets users switch between 'App Sandbox' and 'App Groups' views. When App Groups are selected, the controller automatically detects available group identifiers from the app's entitlements (or configured resources) and lists them as navigable directories, enabling inspection of shared data across app group members.

DebugSwift/Sources/Features/Resources/Files · high confidence

The DebugSwift entry point has changed from a static singleton pattern to an instance-based API, requiring developers to initialize a \DebugSwift\ object and call \setup()\ to configure features, hide specific modules, or enable beta capabilities. This location introduces a suite of new public configuration extensions that allow granular control over debugging tools: \APNSToken\ for tracking push notification registration states, \Network\ for managing URL filtering, request thresholds, and network injection (delays/failures), \Performance\ for configuring leak detection, thread checking, and backtrace capture, \PushNotification\ for simulating notifications, \SwiftUIRender\ for visualizing view updates, \WKWebView\ for web traffic monitoring, and \WebSocket\ for connection tracking. The \FeatureHandling\ module now centralizes the logic for enabling or disabling these swizzled features based on the setup configuration.

DebugSwift/Sources/Settings · high confidence

The Example app now includes dedicated demo views for several new debugging capabilities: Backtrace Capture (programmatic stack inspection via SE-0419), Disk I/O monitoring (with configurable write sizes and continuous logging), Hang/ANR detection (main thread blocking simulation), and a GraphQL Operation Inspector (testing operation parsing against a public endpoint). Additionally, the app features a Core Data browser setup with sample entities (Person, Address, Task) and a Deep Link testing interface that parses and displays URL components. These views are wired into the main navigation and support testing the corresponding DebugSwift panels.

Example/Example · high confidence

The Resources feature now offers a comprehensive suite of tools for inspecting and managing app data. Users can browse and edit HTTP cookies, Core Data, and SwiftData (iOS 17+), in addition to the existing File Manager, User Defaults, and Keychain views. A new 'Persistent Data' tab combines User Defaults and Keychain management with add, export, and delete-all actions, while a dedicated Security Audit view is also available.

DebugSwift/Sources/Features/Resources · high confidence

The Hyperion interface now includes a Measurement feature that allows users to visually inspect and compare the dimensions of UI elements. By tapping on views, users can select a primary view and a comparison view to display precise distance measurements (in points) between them, along with visual guides such as borders and dashed lines. This capability is implemented through a dedicated overlay window and helper classes within the HyperionSwift module, providing a new way to debug layout spacing and alignment issues directly in the app.

DebugSwift/Sources/Features/Interface/HyperionSwift · high confidence

DebugSwift now supports a new Custom Action feature, allowing users to define and execute custom actions via a searchable list interface. This change introduces the underlying model and view model components that enable filtering actions by title and triggering associated closures, providing a flexible way to extend app debugging capabilities.

DebugSwift/Sources/Features/App/CustomAction · high confidence

DebugSwift now persists captured network sessions to local storage using SwiftData (iOS 17+), allowing users to review request history even after the app restarts. This new persistence layer, implemented in NetworkSessionPersistenceManager and NetworkSessionPersistenceStore, introduces configurable settings for session retention duration (defaulting to 7 days) and write batch size (defaulting to 2), giving users control over storage usage and performance. The feature includes automatic purging of expired sessions and supports enabling or disabling persistence via user preferences.

DebugSwift/Sources/Features/Network/Persistence · high confidence

Users can now enable the Agent Debug Log (a beta feature) to aggregate network, crash, console, and event data into a single NDJSON file for AI agents to consume, with a dedicated view to toggle the feature and copy instructions. The App tab now includes a refresh button to update device info, supports custom actions via the shared API, and adds navigation to new debug views including OSLog Console (iOS 15+), Event Timeline, Deep Link testing, and Loaded Libraries.

DebugSwift/Sources/Features/App · high confidence

Users can now explore the internals of specific classes within loaded libraries. The Loaded Libraries screen has been updated with a segmented control to filter between public and private libraries, a search bar to find libraries or classes, and an export button to generate a report of loaded libraries. Tapping a class in a library opens a new Class Explorer view that displays class information, properties, methods, and instance state, and allows users to create an instance of the class if it is a safe NSObject subclass.

DebugSwift/Sources/Features/App/LoadedLibraries · high confidence

DebugSwift now includes a Color Palette feature that extracts all colors from the live view hierarchy, groups similar colors using perceptual distance (CIEDE2000), and detects issues such as low contrast ratios, color-blindness accessibility concerns, and brand-drift deviations. The extracted palette can be exported in multiple formats including Swift (UIColor), CSS variables, JSON tokens, Figma tokens, Tailwind config, and Markdown documentation.

DebugSwift/Sources/Features/Interface/ColorPalette · high confidence

DebugSwift now includes an Event Timeline feature that aggregates debug events from multiple domains (network, performance, interface, app, resources, security) into a single, filterable live stream. Users can view a chronological list of events with domain-specific color badges, filter by domain or text, and clear the timeline. This provides a centralized way to inspect debug activity across different subsystems without switching between individual monitors.

DebugSwift/Sources/Features/App/EventBus · high confidence

The Performance section now includes four new monitoring capabilities. You can capture and view programmatically recorded backtraces (via \DebugSwift.Performance.Backtrace.capture\) with options to clear or share them. A Battery panel displays real-time level, state, and energy impact, including a sparkline history. The Disk I/O panel tracks write rates, lists open file descriptors, and shows storage usage breakdowns (Bundle, Caches, Temp, Documents) alongside 24-hour MetricKit write aggregates. Finally, a Frame Drop Timeline visualizes FPS drops below a configurable threshold, allowing you to review, clear, or share the recorded events.

DebugSwift/Sources/Features/Performance · high confidence

DebugSwift now includes a dedicated Push Notifications feature that allows users to simulate, manage, and inspect push notifications directly within the app. This update adds a new UI section with controllers for viewing notification history, creating custom notifications with various triggers (immediate, delayed, location-based), managing reusable templates, and configuring simulation behavior (such as foreground display, sound, badges, and auto-interaction). The underlying simulator engine tracks notification status (scheduled, delivered, interacted, dismissed, failed) and persists history and templates, providing a comprehensive tool for testing push notification flows.

DebugSwift/Sources/Features/App/PushNotifications · high confidence

The Resources section now includes a dedicated Database Browser that discovers and lists SQLite, Realm, and Core Data files from the app's standard directories. Users can browse table schemas, view paginated row data with search and sort, and edit or add rows in SQLite databases. The feature also supports exporting database contents to CSV, JSON, or SQL formats, and includes an SQL Query Editor for running custom queries against SQLite files. Realm files are validated via header parsing to confirm they are valid Realm stores, though full object introspection is not performed.

DebugSwift/Sources/Features/Resources/Database · high confidence

DebugSwift now includes a Security Audit tool that scans the app's UserDefaults, Info.plist, and app bundle for sensitive keys (like passwords or tokens) and credential files (such as .p12 or .pem). The results are displayed in a new UI view, grouped by severity (Critical, Warning, Info), allowing developers to quickly identify potential security misconfigurations in their storage and resource files.

DebugSwift/Sources/Features/Resources/Security · high confidence

DebugSwift now includes a dedicated UI for monitoring and configuring SwiftUI render performance. Users can enable render tracking, toggle persistent visual overlays, adjust overlay duration and style, and enable console logging via a new settings screen. The underlying tracker provides real-time render statistics and automatically manages overlay lifecycles, including cleanup of orphaned views when persistent overlays are disabled.

DebugSwift/Sources/Features/Interface/SwiftUI · high confidence

The network feature now includes SwiftData entities (NetworkRequestEntity, NetworkSessionEntity) for persistent storage of captured requests, a new HTTPRequestFilter for filtering by method, status code, size, and time, and a HAREncoder that allows exporting captured traffic as HAR 1.2 JSON or cURL commands with automatic redaction of sensitive headers like Authorization and Cookie. Additionally, HttpModel now supports tracking encrypted responses via a new isEncrypted flag and decryptedResponseData property, while WebSocket monitoring models have been added to track frames and connection status.

DebugSwift/Sources/Features/Network/Models · high confidence

DebugSwift now includes several new helpers in the Network feature to enhance debugging workflows. EncryptionService adds support for detecting and decrypting AES-128/256 encrypted network traffic, including custom decryptor registration. GraphQLInspector and its adapter provide detailed inspection of GraphQL operations, variables, and responses by parsing request bodies. HARExportAdapter enables exporting captured network requests as HAR 1.2 files or copying them as cURL commands for replay. NetworkInjectionManager and related config classes introduce request delay injection, failure simulation (timeouts, connection lost, HTTP errors, etc.), and response body rewrite rules with persistence. NetworkSessionRewriteRuleBuilder allows generating rewrite rules from captured session history. NetworkThresholdTracker monitors request rates and can block requests exceeding configured thresholds. RewriteRulesCSV supports importing and exporting rewrite rules via CSV files. WKWebViewNetworkMonitor installs JavaScript injection to monitor navigation and network activity within WKWebViews. WebSocketMonitor enables monitoring of WebSocket messages through method swizzling.

DebugSwift/Sources/Features/Network/Helpers · high confidence

The Network Details section now includes dedicated view controllers for inspecting and editing network bodies, managing headers, and configuring network injection. BodyBrowserViewController parses and displays JSON, form data, or raw text in a structured table with search and copy capabilities, while BodyEditorViewController allows in-place editing of JSON bodies with validation and save-back functionality. HeadersViewController provides searchable header lists with long-press copy and nested JSON browsing. NetworkInjectionSettingsController exposes UI for configuring request delay, network failure injection, and response modifiers. ResponseModifierSettingsController manages rewrite rules with search and a master toggle, and NetworkThresholdController monitors request volume thresholds with breach history. These changes enhance the ability to inspect, modify, and control network traffic directly within the app's network detail views.

DebugSwift/Sources/Features/Network/Details · high confidence

The Network feature now consolidates HTTP, WebSocket, and WebView monitoring into a single view with a segmented control for switching between modes. Users can filter HTTP requests using a new advanced filter button and search across URL, status code, and end time. The interface displays real-time HTTP statistics (total requests, success rate, average response time, total time) and supports separate data handling for each mode, including WebSocket connection tracking and WebView request identification.

DebugSwift/Sources/Features/Network/Main · high confidence

The User Defaults resource view now supports tracking changes, direct editing, and exporting data. A new diffing system captures a snapshot of the current state and detects added, modified, or removed keys, allowing users to review these changes in a dedicated 'Defaults Diff' view and undo individual modifications. The main list view has been updated to allow adding new keys, editing existing values (with automatic type parsing for integers, doubles, booleans, and JSON), and deleting entries. Additionally, users can now export the current User Defaults data as a JSON file.

DebugSwift/Sources/Features/Resources/UserDeafults · high confidence

Users can now monitor WebSocket traffic via a new dedicated data source that manages connections, frames, and search/filtering capabilities. For HTTP traffic, the system now supports wildcard URL filtering (allowing or ignoring URLs based on patterns) and automatic response body decryption when enabled, using either custom decryptors or registered keys. Additionally, HTTP requests are now published to the event timeline and persisted on iOS 17+.

DebugSwift/Sources/Features/Network/DataSource · high confidence

The Example\_SwiftUI Xcode project, including its project file, workspace configuration, and shared data, has been removed from the repository. This eliminates the Swift UI example application and its associated build settings, such as the DebugSwift framework integration and Portuguese (Brazil) localization support, from the codebase.

_Example\_SwiftUI/Example\SwiftUI.xcodeproj · high confidence

The Example\_SwiftUI directory has been removed, deleting the SwiftUI example app including its main entry point, content views, asset catalogs, and entitlements.

_Example\_SwiftUI/Example\SwiftUI · high confidence

The base view controllers (BaseController, BaseTableController, TabBarController) now unconditionally set the user interface style to dark, removing the previous iOS 13 availability check. Additionally, the tab bar configuration has been updated to allow custom view controllers to be injected via \DebugSwift.App.shared.customControllers\, merging them with the default set (Network, Performance, Interface, Resources, App) rather than using a hardcoded list. Minor style updates include using \UIColor.white\ and \UIColor.black\ explicitly and changing the close button label from a localized string to "Close".

DebugSwift/Sources/Base · high confidence

The console helper layer has been refactored to capture both standard output and standard error streams, replacing the previous single-stream interception. Stdout is now captured by intercepting the underlying C \\_write\ function, while stderr is captured by redirecting file descriptor 2 to a pipe, ensuring that error logs from system frameworks and third-party libraries are visible in the DebugSwift console. This change also resolves a memory leak and file descriptor restoration issue in the stderr capture logic, and introduces thread-safe, lock-protected storage for console output to prevent crashes when logging from background threads.

DebugSwift/Sources/Features/App/Console/Helpers · high confidence

The Console feature now retrieves output via a centralized \ConsoleOutput\ manager instead of the previous \LogIntercepter\, ensuring consistent handling of print and NSLog streams. Users can now share console logs directly through a new share action, and the interface displays a clearer 'No data found' message when the log is empty. Additionally, the search toggle property has been corrected from 'Actived' to 'Activated' for consistency.

DebugSwift/Sources/Features/App/Console · high confidence

The Crash Detail screen now attempts to load a bundled symbol map to resolve raw stack traces into human-readable symbols, falling back to raw traces if unavailable. The export options have been expanded: tapping the share button now presents an action sheet allowing users to either export the report as a PDF or copy the full crash text (including symbolicated traces) directly to the clipboard. Additionally, the view now displays the device's connection type in the crash details and adds a dedicated 'Error Log' section if error output is present.

DebugSwift/Sources/Features/App/Crash/Detail · high confidence

The Crash list now displays entries sorted by date (newest first) and uses English strings for the title, alert dialogs, and empty state instead of localized keys. The view controller also switches row height to automatic dimension and explicitly uses UIColor.black for backgrounds.

DebugSwift/Sources/Features/App/Crash/Main · high confidence

The crash detail snapshot screen has been updated to display additional context alongside the crash image. Users can now see a custom title and a multi-line description text above the snapshot image, replacing the previous hardcoded 'Snapshot' title and black background. This allows for more informative crash reports by providing specific details about the crash context directly in the view.

DebugSwift/Sources/Features/App/Crash/Detail/Snapshot · high confidence

Crash reports now include symbolicated stack traces by loading a build-time symbol map, replacing the previous regex-based parsing. The crash context has been expanded to include device reachability status and stderr output alongside the existing console logs and UI snapshots. Additionally, the crash manager and handler classes have been refactored from static enums to singleton instances to improve thread safety and state management.

DebugSwift/Sources/Features/App/Crash/Helpers · high confidence

The DebugSwift debug interface now displays APNS push token details (including registration state and environment) and current network connection type in the User Info section. The floating debug ball now provides visual feedback for HTTP request success/failure, WebSocket connections, and memory leak detection events. Window management improvements include disabling the interactive pop gesture in the debugger navigation controller, fixing the floating ball's touch blocking when hidden, and correcting its position during orientation changes and layout updates.

DebugSwift/Sources/Helpers/Managers · high confidence

The Example project has been updated to the Xcode 15 project file format (objectVersion 70), replacing the legacy manual file references with modern file-system synchronization. This change removes the CocoaPods dependency (Pods\_Example.framework) and replaces it with the DebugSwift framework, which is now linked directly to the application target. Additionally, the project structure now includes an ExampleTests target and an Example.xctestplan file, streamlining the setup for running tests.

Example/Example.xcodeproj · high confidence

The DebugSwift floating button's design system constants (screen dimensions, safe area insets, and ball position) have been converted from static let values to @MainActor computed vars. This ensures that layout metrics like screen width, height, and safe area padding are re-evaluated dynamically rather than being captured once at load time, which helps maintain correct positioning if the device orientation or safe area changes. Additionally, the Example workspace configuration referencing CocoaPods has been removed.

DebugSwift/Sources/Helpers/FloatingButton/DesignSystem, Example/Example.xcworkspace · high confidence

The crash reporting feature now provides cleaner, more readable call stacks by integrating a Swift symbol demangler (CwlDemangle) and a dedicated parser (CallStackParser). This change replaces raw, mangled stack traces with human-readable class and method names, filtering out internal DebugSwift frames and formatting the output with indexed headers for easier debugging.

DebugSwift/Sources/Features/App/Crash/Helpers/CallStackSymbols · high confidence

The floating debug button now persists its position across app launches by restoring saved coordinates instead of defaulting to a fixed screen location. Animation requests are debounced to prevent high CPU usage and crashes, with a 0.1-second delay ensuring only the latest state triggers a visual update. Gesture handling has been refined to support dragging, tapping, and long-pressing (for HyperionSwift toggling), while the label now accurately reflects combined HTTP and WebSocket connection counts. Additionally, the view correctly updates its appearance in response to measurement state changes and removes observers when hidden to prevent memory leaks.

DebugSwift/Sources/Helpers/FloatingButton/Views · high confidence

The location simulation feature now tracks all CLLocationManager instances to ensure simulated locations are correctly propagated to every active manager, preventing crashes or stale data when removing or switching simulated locations. The UI has been updated to use explicit English titles ('Simulate Location', 'Select Location', 'Custom...') instead of localized keys, and the map selection view is now explicitly marked as @MainActor for thread safety.

DebugSwift/Sources/Features/App/Location · high confidence

The Interface feature panel now displays a permission-filtered list of tools, adding toggles for Dark Mode and Measurement, and direct navigation entries for SwiftUI Render Settings, Documentation Recorder, and Color Palette. The view controller now listens for measurement state changes to refresh the table and implements orientation forwarding via a new OrientationForwardingNavigationController that delegates autorotation decisions to the app's top view controller.

DebugSwift/Sources/Features/Interface · high confidence

The Keychain resource view has been updated to display and manage keychain items across all service identifiers, rather than being limited to a single default service. This change enables users to view, edit, add, and delete keychain entries regardless of their specific service tag. The underlying KeychainService module has also been refactored to remove public visibility from internal enums and structs, improving encapsulation and preparing the codebase for concurrency safety.

DebugSwift/Sources/Features/Resources/Keychain · high confidence

The debug helper tools in the Tools module have been refactored to persist configuration settings (such as the debugger toggle and impact feedback enable/disable) in UserDefaults rather than relying on static in-memory state, allowing these preferences to survive app restarts. Additionally, the LaunchTimeTracker has been converted to a singleton class with a more robust startup time measurement that validates sysctl results and handles edge cases, while the Debug utility now supports variadic print arguments and restricts execution to DEBUG builds.

DebugSwift/Sources/Helpers/Tools · high confidence

The legacy Xcode workspace file (contents.xcworkspacedata) has been removed from the .swiftpm directory. This cleanup simplifies the package structure by eliminating an outdated workspace reference that is no longer required for the Swift Package Manager integration.

.swiftpm · high confidence

The local DebugSwift podspec (version 0.0.1) and all associated CocoaPods support files—including the Manifest.lock, project.pbxproj, and target support configurations—have been removed from the Example/Pods directory. This cleanup eliminates the local pod dependency and its generated build artifacts, indicating a shift in how the DebugSwift library is integrated or managed within the example application.

Example/Pods · high confidence

The UserInterfaceToolkit now initializes its dark mode state by checking if the app has explicitly overridden the user interface style on the key window, falling back to system preferences if no window is available yet. It also introduces a new \darkModeEnabled\ property that allows users to toggle between light and dark modes, which updates the color scheme for all windows via \overrideUserInterfaceStyle\. Additionally, the toolkit now supports tracking SwiftUI render changes and selecting grid overlay color schemes, enhancing the debugging experience for interface customization.

DebugSwift/Sources/Features/Interface/Helpers · high confidence

This update enhances the stability and compatibility of the DebugSwift helper extensions. It fixes a crash caused by NewRelic detecting renamed \viewDidAppear\ selectors by switching to IMP-replacement for swizzling, and corrects HTTP header parsing to use standard accessor methods. The codebase now supports iOS 16+ scene geometry updates for proper orientation handling, adds safe collection subscripting, and improves JSON serialization with new \toJSONString\ and \asJsonStr\ methods. Additionally, it introduces light/dark mode support for colors, refactors navigation bar appearance settings to use modern APIs, and updates the \DispatchQueue.once\ implementation to be thread-safe.

DebugSwift/Sources/Helpers/Extensions · high confidence

The app's user interface text has been updated to reflect new capabilities and improved clarity. New strings have been added to support the Memory Leak Detector (e.g., "Leaks", "Show Leaks"), HTTP Cookies, and Dark Mode toggles. The Device Info screen now includes labels for Reachability Status (Cellular, WiFi, No Connection). Additionally, crash report handling has been enhanced with new options to "Copy Text" and "Share as PDF", along with corresponding confirmation alerts. Existing strings, such as "Simulate Memory Warning", have been capitalized for consistency.

DebugSwift/Resources · high confidence

The View Debugger interface has been completely redesigned to use a modern, system-native appearance. The hierarchy list now features a cleaner layout with improved typography and visual separators, while the detail view presents a structured, sectioned breakdown of element properties (such as accessibility, constraints, and layer info) alongside a snapshot image, replacing the previous simple text view. Additionally, the underlying data model for view elements has been enhanced to expose significantly more debugging information, including memory addresses, gesture recognizers, and specific control states, providing developers with deeper insight into the UI tree.

DebugSwift/Sources/Features/Interface/ViewDebugger · high confidence

The Example project scheme has been upgraded to Xcode 16.4, introducing explicit build architecture settings and a dedicated test plan reference for the ExampleTests target. Additionally, the default build configurations for profiling, archiving, and launching have been switched from Release to Debug to streamline the development and debugging workflow.

Example/Example.xcodeproj/xcshareddata · high confidence

The DebugSwift floating button's transition animations now correctly clear stale layer masks on the from and to views. Previously, masks applied during push/pop transitions were not always reset, causing the DebugSwift menu to appear shrunk or distorted after interactions like search or keyboard display. This change ensures the UI returns to its normal state after every transition.

DebugSwift/Sources/Helpers/FloatingButton/Transitions · high confidence

The floating debug button now correctly adjusts its position when the device rotates to landscape mode. A new helper ensures the button remains within safe, visible bounds by clamping its coordinates based on the current window's safe area and layout constraints, preventing it from being hidden or positioned incorrectly after rotation.

DebugSwift/Sources/Helpers/FloatingButton/Helpers · high confidence

This update enhances the DebugSwift network interception helpers to prevent crashes and preserve security settings. It introduces a \URLSessionDelegateRegistry\ to correctly forward authentication challenges to the app's original delegates, fixing issues where custom delegates were ignored. The \SwizzleSessionConfiguration\ helper now safely handles \nil\ protocol classes and explicitly stores TLS minimum/maximum version settings in \UserDefaults\ to ensure they are preserved during interception. Additionally, HTTP error descriptions are now hardcoded English strings instead of relying on localized keys, and new wildcard pattern matching utilities (\String+URLPattern\) are added to support flexible URL filtering.

DebugSwift/Sources/Features/Network/Helpers/Helpers · high confidence

Added test coverage for Agent Debug Log, Crash Symbolication, EventBus, and OSLog Console; Added test coverage for network data source encryption and URL filtering; Added tests for ConsoleOutput and StderrCapture stability; Added tests for Core Data, database, security, and UserDefaults features; Added tests for HAR export, HTTP request filtering, and encryption model; Added tests for network helper components; Added tests for network request encryption and decryption UI behavior; Added tests for network request logging and encryption configuration; Added tests for new Performance panel capabilities; Added tests for the documentation recorder debug tool and SwiftUI render tracking; Added unit tests for AppCustomActionViewModel; Added unit tests for CrashDetailViewModel; Added unit tests for DebugSwift helper extensions and managers; Added unit tests for DeepLinkViewModel; Added unit tests for base controllers and feature enums.

DebugSwift has been updated to version 1.11.3, raising the minimum deployment target from iOS 12 to iOS 13 and switching the Swift language mode from 5 to 6 in the Package.swift manifest. The podspec now explicitly supports Apple Silicon simulators (arm64) and includes configuration for source-based builds, while the Example project has been restructured to use a Gemfile for dependencies instead of a Podfile.

(dependencies) · high confidence

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

• CAI 61 → 61 (-0.1)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 90 → 90 (-0.1)
• Architecture 93 → 87 (-5.6)
• Maturity 64 → 64 (+0.2)
• Readiness 52 → 54 (+1.8)
• Security 61 → 74 (+13.1)
• Domain Modelling 90 → 90 (+0.0)
• Performance 61 (new)

• Duplicated block (20–21 lines × 3) (DebugSwift/Sources/Features/App/Crash/Detail/CrashDetailViewController.swift)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3

• Coverage not measured — Swift suite
• Duplicated block (12 lines × 2) (Example/Example/Hyperion/HyperionSwiftDemoView.swift)
• Duplicated block (13 lines × 2) (Example/Example/BacktraceDemoView.swift)
• Duplicated block (20–21 lines × 3) (DebugSwift/Sources/Features/App/Crash/Detail/CrashDetailViewController.swift)
• Duplicated block (7 lines × 2) (DebugSwift/Sources/Features/App/LoadedLibraries/ClassExplorer/ClassExplorer.ViewModel.swift)
• Duplicated block (8 lines × 2) (Example/Example/Hyperion/HyperionSwiftDemoView.swift)
• Duplicated block (8–12 lines × 3) (Example/Example/NetworkInjection/NetworkInjectionExampleView.swift)
• Duplicated block (9 lines × 11) (Example/Example/ContentView.swift)
• Duplicated block (9 lines × 2) (DebugSwift/Sources/Features/App/LoadedLibraries/ClassExplorer/ClassExplorer.ViewModel.swift)
• Inconsistent naming for feature enable/disable actions. The setup method uses 'hide' for features and 'disable' for swizzle features, while the public API methods use 'show'/'hide' for the entire UI and 'toggle' for state changes. This creates ambiguity: does 'hide' in setup mean 'disable functionality' or 'hide from UI'? Furthermore, show/hide are imperative UI actions, whereas setup is configuration. The term 'disable' is used for swizzling (a technical implementation detail) while 'hide' is used for features (likely UI visibility), but both are passed to the same configuration method.
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #1
• Projects may be oversized for their cohesion

• 3 commits — 1 feature/other, 2 fixes

• DebugSwift/Sources — 3 commits

• fix: Fix Mac Catalyst backtrace compilation (#455)
• fix: fix(float): don't latch isShowingDebuggerView when the debugger isn't ready (#448)
• change: feat(network): add option to disable credential redaction when copying cURL (#451) (#452)

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

DebugSwift/DebugSwift 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.