facebook/idb

This system is an iOS and macOS device management toolkit that provides programmatic control over simulators and physical devices through a gRPC-based architecture. It enables users to manage device lifecycles, install applications, interact with accessibility features, and execute XCTest suites via a Python client and CLI. The framework supports low-level operations such as file management, HID input, and video streaming, backed by shared Swift libraries for robust device interaction.

41 changes.

This period focused on modernizing the idb ecosystem by migrating core frameworks like FBSimulatorControl and FBDeviceControl from Objective-C to Swift and establishing FBControlCore as a shared foundation. The team introduced a new gRPC-based protocol and refactored the Python CLI to use asyncio, while simultaneously open-sourcing the project under the MIT license and restructuring the documentation website.

105 changes.

The project underwent a comprehensive migration of its core libraries and CLI tools from Objective-C to Swift, adopting async/await concurrency patterns throughout. This period established a new gRPC-based companion architecture to centralize device and simulator management, replacing fragmented command execution with a unified, typed service layer. Significant efforts were also directed toward enhancing simulator capabilities, including modern HID transport, accessibility bridging, and video recording infrastructure.

The PrivateHeaders/AccessibilityPlatformTranslation directory now contains the full set of Objective-C headers and module map for the AccessibilityPlatformTranslation private framework. This adds the public interface for AXPMacPlatformElement (the Mac accessibility element wrapper), AXPTranslator and its platform-specific subclasses (AXPTranslator\_iOS, AXPTranslator\_macOS) which handle translation between platform accessibility APIs and a common representation, and supporting data models like AXPTranslationObject, AXPTranslatorRequest, and AXPTranslatorResponse. The addition also includes helper protocols (AXPTranslationDelegateHelper, AXPTranslationTokenDelegateHelper), platform-specific element data (AXPiOSElementData), and stub headers for standard Foundation protocols to ensure the framework imports cleanly as a module.

PrivateHeaders/AccessibilityPlatformTranslation · high confidence

A new iOS companion application, ReplHost, is included in the distribution to support REPL and accessibility testing scenarios. The app provides a default interface that allows on-demand requests for privacy-gated services (camera, microphone, contacts, and photos), enabling tests to verify that pre-approved permissions are correctly recognized by the host process. Additionally, it supports two specialized test modes: a fixed-accessibility fixture for stable end-to-end accessibility tree testing, and a slow-accessibility fixture that blocks the main thread to simulate heavy accessibility serialization and verify timeout handling.

REPLHost · high confidence

Introduces a new \SocketServer\ class in \FBControlCore/Sockets\ that manages TCP listening sockets. The server binds to a specified port (supporting IPv6 and ephemeral port selection), accepts incoming client connections, and delegates connection events to a conforming \SocketServerDelegate\. The implementation uses throwing methods for \startListening\ and \stopListening\ to handle errors such as port binding failures or invalid states, ensuring robust error reporting for socket operations.

FBControlCore/Sockets · high confidence

A new Swift Package Manager plugin (GenerateBuildInfo) has been added to the idb-repl project. This plugin automatically generates a BuildInfo.swift file during the build process, stamping the current date and time into constants (kBuildDate and kBuildTime) that are used by the --version command. This provides the SPM build with the same build-time metadata capabilities previously available only via xcodebuild pre-build scripts and Buck genrules.

Plugins/GenerateBuildInfo · high confidence

The Fixtures/Source directory now includes complete Xcode projects and source code for iOS and Mac test fixtures, providing ready-to-use applications and test bundles for UI and unit testing scenarios. This includes the FBTestRunnerApp, iOSAppFixture, iOSUITestFixture, MacAppFixture, and MacUITestFixture, along with their corresponding test targets (iOSUnitTestFixture, MacUnitTestFixture, iOSAppFixtureAppTests, iOSUITestFixtureUITests, MacUITestFixtureUITests). These fixtures support testing features such as async expectations, process stalling/crashing simulation, and UI interaction verification on both iOS and macOS platforms.

Fixtures/Source · high confidence

Introduces the Python client for idb (iOS Debug Bridge), including the client library, CLI, gRPC bindings, and shared utilities. A README file is added to document the folder's contents and its export to the open-source facebook/idb repository.

idb · high confidence

A new \sim-video\ command-line tool is introduced in the VideoRecorder CLI to record or stream simulator video with JSON-line overlay control. It provides three subcommands: \record\ to capture playable MP4/MOV files with configurable encodings (H.264, HEVC, MJPEG) and overlay bars; \stream\ to output encoded frames to a file or stdout with transport options; and \clip\ to cut precise, independently playable clips from existing recordings by decoding and re-encoding the specified time range. The tool supports overlay customization, frame-rate control, and reports recording metadata including the timestamp of the first captured frame.

Tools/VideoRecorder/CLI · high confidence

The CompanionLib/Reporting module now includes a TargetStateChangeNotifier that monitors target sets and writes their state changes to standard output. This enables external consumers to receive real-time updates about device availability and status changes via stdout, bypassing standard I/O buffering for immediate delivery.

CompanionLib/Reporting · high confidence

The AXRuntime private framework headers now include a new AXTraits.h file defining accessibility trait bitmasks (such as AXTraitButton, AXTraitLink, and AXTraitImage) extracted from iOS runtime symbols, along with a module.modulemap to expose the AXRuntime module. This provides developers with explicit constants for identifying and categorizing accessibility elements based on their traits.

PrivateHeaders/AXRuntime · high confidence

New header files have been added to the PrivateHeaders/SimulatorBridge directory, defining the \SimulatorBridge\ class and its associated protocols (\SimulatorBridge-Protocol.h\, \AXPTranslationRuntimeHelper-Protocol.h\). These headers expose methods for controlling simulator location simulation, accessibility element inspection, game controller input, and hardware keyboard settings, enabling code that interacts with the iOS Simulator's internal bridge mechanisms.

PrivateHeaders/SimulatorBridge · high confidence

A new TestCrashShim component has been introduced to the Shims/Shimulator directory. This shim automatically logs the application's architecture, command-line arguments, and environment variables upon startup. Additionally, it supports a controlled crash simulation: if the SHIMULATOR\_CRASH\_AFTER environment variable is set, the shim will force a crash after the specified number of seconds, aiding in debugging and stability testing.

Shims/Shimulator/TestCrashShim · high confidence

Added a comprehensive set of Objective-C header files to the XCTestPrivate module to support remote test automation. These headers expose internal XCTest classes and protocols, including DTXConnection extensions for proxy channels, accessibility element handling, synthesized input events, and test issue reporting. The update also introduces messaging channel protocols that define the communication interfaces between the IDE, test daemon, and test runner, enabling features such as UI automation, capability exchange, and detailed test result reporting.

PrivateHeaders/XCTestPrivate · high confidence

Added new header files (GSEvent.h, Indigo.h, Purple.h, Mach.h) and a module map to PrivateHeaders/SimulatorApp that document the reverse-engineered wire formats for the Simulator's HID transport (Indigo) and the GSEvent/PurpleWorkspacePort mach message protocol. These headers define the structures and constants for digitizer, button, wheel, and orientation events, enabling developers to understand and potentially interact with the low-level input and system event mechanisms used by the Simulator.

PrivateHeaders/SimulatorApp · high confidence

FBControlCore now provides first-class integration with Swift concurrency. The new \AsyncFBFutureBridge\ module allows awaiting \FBFuture\ results directly using \async/await\, automatically handling cancellation propagation between Swift Tasks and the underlying futures. Additionally, \AsyncPolling\ introduces \pollUntilTrue\ for condition-based waiting with deadlines, and \FBFuture+Sync\ adds synchronous blocking methods (\await\, \block\) for Objective-C callers that need to wait on futures without callbacks.

FBControlCore/Async · high confidence

The website now automatically generates framework documentation pages from the in-repo READMEs for FBControlCore, XCTestBootstrap, FBDeviceControl, and FBSimulatorControl, and publishes end-to-end demo clips with their terminal sessions and source links. A new build-time validation step checks Mermaid diagrams for syntax errors to prevent broken visuals in the browser.

website/scripts · high confidence

The website now supports the custom domain fbidb.io, configured via a new CNAME file in the static assets. Additionally, the Docusaurus branding logo (docusaurus.svg) has been added to the static image directory to ensure proper visual identity in the generated documentation site.

website/static · high confidence

The simulator's xctest and REPL (Read-Eval-Print Loop) commands have been extracted into the new \SimulatorXCTest\ module. This change separates test execution and interactive debugging capabilities from the core simulator control logic, allowing consumers who do not need to run tests or use the REPL to avoid linking the \XCTestBootstrap\ dependency. The module provides \SimulatorXCTestCommands\ for running and listing tests via the testmanagerd socket, and \SimulatorReplCommands\ for launching and managing REPL sessions, exposing these via new \xctest\ and \repl\ properties on the \Simulator\ type.

SimulatorXCTest · high confidence

The FBDeviceControl framework, previously an internal Facebook component, is now available as an open-source Swift library under the MIT license. This release includes a full migration of the codebase from Objective-C to Swift, exposing iOS device control capabilities such as device management, file access (AFC), video streaming, and debugging via debugserver. The framework is designed to be linked directly by macOS applications or used via the idb CLI, providing finer-grained control over connected iOS devices than the command-line interface alone.

FBDeviceControl · high confidence

The REPL/IDB module now exposes a unified \IDB\ namespace for UI automation, adding structured data types and new capture commands. Users can now retrieve the full accessibility hierarchy via \IDB.ui.describeAll()\, which returns strongly-typed \AXElement\ objects instead of raw data. Additionally, the API adds \IDB.screenshot\ for capturing PNG artifacts or \CGImage\ objects (full screen, by rect, or by accessibility label) and \IDB.video\ for starting and stopping screen recordings, providing programmatic access to visual state and recording control within the REPL environment.

REPL/IDB · high confidence

The \proto/idb.proto\ file introduces the complete gRPC service contract for the \idb\ companion, defining the \CompanionService\ interface and its associated message types. This establishes the wire format for device management, accessibility interactions, app lifecycle operations (launch, install, terminate), file operations, video streaming, and settings configuration, serving as the foundational API for client-companion communication.

proto · high confidence

The website now renders recorded demos as interactive transcripts. A new DemoTranscript component displays a video clip alongside a terminal session, keeping them synchronized so users can see the command output that corresponds to specific moments in the video. Notes within the demo highlight relevant lines in the terminal output, and the interface allows users to view one step at a time or expand the full command history.

website/src/components · high confidence

The idb/common library now detects when it is driven by an AI coding agent by checking environment variables (AI\_AGENT, AGENT, CODING\_AGENT\_METADATA, CLAUDECODE) and exposes this via the new agent.py module. Additionally, the plugin system has been expanded with new lifecycle hooks (on\_command\_parsed, on\_invocation\_result) and a scoped invocation metadata context, allowing plugins to inspect and modify command parsing and invocation results. Companion management has been refactored to use a new CompanionSet class for atomic state file operations and a dedicated CompanionSpawner for process lifecycle, while command routing is now handled by a new Command/CompositeCommand/CommandGroup hierarchy.

idb/common · high confidence

Adds a new \AXBridge\ backend that routes accessibility operations through a dedicated in-guest \SimulatorFrameworkBridge\ process. This change introduces a new transport layer (\AXBridgeOneshotTransport\), a typed error model (\AXBridgeError\) for guest-side failures, and display-scoped routing to ensure reads and writes target the active display. It also adds quiescence streaming to track application state changes and refines element filtering to drop zero-size or off-screen elements, providing a more robust and isolated accessibility interface for simulator automation.

FBSimulatorControl/Accessibility · high confidence

The new CompanionDiscovery library centralizes the discovery, spawning, and lifecycle management of companion processes. It supports both v1 (idb\_companion) and v2 (idb2) generations, keeping their state files and logs in separate directories (/tmp/idb and /tmp/idb2) to prevent collisions. The library handles local domain-socket discovery on macOS and remote TCP companion selection on other platforms (like Linux), including an idle shutdown timer for spawned companions. It also introduces TLS support for TCP connections via a pluggable CompanionTLSProvider and ensures safe concurrent access to the companion registry using file locking.

CompanionDiscovery · high confidence

A new Configuration module has been added to CompanionLib, providing core types for managing application settings and connectivity. This includes IDBPortsConfiguration for handling debug and gRPC ports (TCP or Unix domain sockets) via UserDefaults, GRPCConnectionTarget to abstract connection targets, and configuration structs for dSYM bundle linking (DsymInstallLinkToBundle, DsymBundleType) and hosted test execution (IDBAppHostedTestConfiguration). The module also exposes a global event reporter singleton in IDBConfiguration.

CompanionLib/Configuration · high confidence

Added a new CompanionServer library that enables executing CLI commands on a companion device via a local Unix domain socket or TCP connection. The server listens for newline-delimited JSON-RPC requests, processes them asynchronously, and returns the command output. It supports optional TLS 1.2+ encryption for TCP connections and includes an idle shutdown timer to automatically terminate the server after a period of inactivity.

CompanionServer · high confidence

FBControlCore is introduced as the foundational framework for the idb project, providing the shared interfaces and machinery used by FBSimulatorControl, FBDeviceControl, and XCTestBootstrap. It defines the \Target\ protocol to allow callers to treat iOS Simulators and Devices interchangeably, along with command protocols, configuration types, asynchronous execution models (FBFuture and Swift Concurrency), and process/IO abstractions.

FBControlCore · high confidence

Added a new \Shims/Repl\ module that provides the infrastructure for the interactive REPL in both launched applications and test bundles. For apps, \AppReplEntry\ automatically starts the REPL socket server on library load when the \IDB\_REPL\_APP\_AUTOSTART\ environment variable is set, ensuring the server runs on a background thread to avoid blocking the main run loop. For tests, \TestRepl\ exposes a \start\ method that generates \.swiftinterface\ files by probing the target image's Swift runtime metadata (using \RuntimeProbe.swift\) and then serves the REPL session. The module is built as dynamic libraries (\libRepl-iOS\ and \libRepl-macOS\) with a deployment target of iOS/macOS 15, using weak imports for \XCTestCase\ to allow injection into processes that may not have XCTest linked.

Shims/Repl · high confidence

Added a new extensible IPC protocol (Shimulator) that enables communication with the iOS simulator via Unix domain sockets. This includes the \ShimulatorClient\ for handling incoming requests and delegating to handlers, the \ShimulatorServer\ for accepting connections and polling responses, and the \ShimulatorProtocol\ definitions for request/response structures and socket path generation. This provides the foundational mechanism for simulator interaction within the Shims layer.

Shims/Shimulator/Protocol · high confidence

This change introduces the \SimulatorFrameworkBridgeProtocol\ module, establishing the foundational wire format and command structure for communication between the macOS host and the simulator guest. It defines \BridgeCommand\ to unify CLI arguments and socket frames for operations including DNS, dynamic-store snapshots, proxy settings, notifications, health checks, and accessibility (AX) interactions. The protocol specifies \BridgeAXWire\ for accessibility vocabulary, detailing node attributes (such as traits, frames, and hit-test results), error kinds, and verbs (like \describe\, \hitTest\, and \quiet\). Additionally, it implements \BridgeJSONValue\ for robust JSON serialization and \BridgeProtocol\ for versioned request/response envelopes, ensuring that reads can be safely retried after connection failures while writes are not.

SimulatorFrameworkBridgeProtocol · high confidence

The new XCTestBootstrap framework provides a macOS library for running XCTest bundles on iOS Simulators, iOS Devices, and macOS. It enables listing tests within .xctest bundles, executing logic, application, and UI tests, and handles the client-side DTX protocol communication with testmanagerd. The framework also offers structured, machine-readable test result reporting. This component is primarily an implementation detail for idb's test execution capabilities.

XCTestBootstrap · high confidence

This change adds a new CompanionLib/Utility module containing core infrastructure for the companion application. It introduces IDBLogger for managing global log output to stderr and optional files, and FileDrainWriter for streaming subprocess stdout to RPC responses. It also provides MultisourceFileReader for handling streamed file uploads and extraction, RequestStreamReader for safely iterating gRPC request streams, and IDBStorage/BundleStorage for managing test bundle installation and architecture validation. Additionally, it includes ProcessTermination for async process exit waiting and retroactive Sendable conformances for legacy types to support Swift concurrency.

CompanionLib/Utility · high confidence

A new BridgeQueues enum has been added to the CompanionLib/BridgeFuture module to facilitate bridging between Objective-C and async Swift worlds. This component exposes two specific dispatch queues: a serial queue dedicated to converting FBFuture calls to Swift awaitable values, and a concurrent user-initiated queue for delivering results in command-executor callbacks.

CompanionLib/BridgeFuture · high confidence

This change introduces a suite of new Python scripts within the CI module to enhance the reliability and output of the continuous integration pipeline. A new \check\_documentation\_links\ tool validates that internal links in documentation files resolve correctly, preventing broken references in the published site. The \dependency\_lock\ script ensures build consistency by verifying that the resolved Swift Package Manager graph matches the shared lockfile and can prepare codegen manifests. End-to-end testing is restructured via \end\_to\_end\_shard\ to run tests in parallel shards (demos, UI, system, and remainder), with \provision\_simulator\ handling dynamic simulator setup and \collect\_diagnostics\ gathering logs and crash reports. Finally, \generate\_documentation\ automates the creation of demo assets by cutting individual video clips and terminal asciicasts from end-to-end run artifacts.

CI · high confidence

This change introduces a new Swift-based CoreDevice transport layer in FBSimulatorControl/CoreDevice, replacing legacy mechanisms for interacting with simulator hardware features. It adds structured Codable models for the CoreDevice XPC envelope (CoreDeviceEnvelope.swift) and a session manager (CoreDeviceSession.swift) that handles both one-shot requests and streaming events with deadline-bound cancellation. The layer implements specific protocols for reading display information (SimulatorDisplayProtocol.swift), streaming hinge angle data (SimulatorHingeProtocol.swift), querying motion capabilities (SimulatorMotionCapability.swift), reading orientation (SimulatorOrientationProtocol.swift), and discovering touchscreens (SimulatorTouchscreenProtocol.swift). This enables more robust handling of simulator displays, including legacy fallbacks for older runtimes, and supports modern features like hinge angle streaming and vendor HID orientation control.

FBSimulatorControl/CoreDevice · high confidence

The FBDeviceControl/Management area now includes a new Swift-based device management implementation. This introduces \AMDeviceManager\ and \AMRestorableDeviceManager\ to discover and track connected devices via MobileDevice notifications, a \DeviceSet\ to aggregate these sources, and a \Device\ class that unifies \MobileDevice\ and \RestorableDevice\ backings while caching target information. The \AMDeviceUsage\ enum handles connection, pairing, and session lifecycle, while \DeviceStorage\ manages device attachment states. A new \AMDefines.h\ header provides C typedefs and function pointers for the underlying MobileDevice API, and \LegacyDeviceNames.swift\ maps product identifiers to human-readable names.

FBDeviceControl/Management · high confidence

A new ReplSocketServer component has been added to the REPL/Executor module, introducing a Unix-domain socket interface for REPL communication. This server implements a length-prefixed binary frame protocol (4-byte big-endian header followed by binary property list payloads) to support arbitrary binary data exchange. It provides session management features including stable session IDs and run indices that persist across client reconnects in long-lived app contexts, allowing sessions to be reattached. The server also sends a greeting frame containing generated Swift interface file paths and supports invoking host commands via dynamic library loading.

REPL/Executor · high confidence

A new command-line executable, SimulatorFrameworkBridge, is now deployed inside the iOS and tvOS simulators to allow idb\_companion to programmatically manage privacy permissions and system state. This guest binary uses TCC entitlements to approve or revoke access for camera, microphone, photos, and contacts, and leverages HealthKit and RunningBoard frameworks to read/set health data and query frontmost app status. It also exposes services for reading accessibility trees, managing notification settings, and controlling photo library and contacts data, all communicated via a shared Unix socket framing protocol.

SimulatorFrameworkBridge · high confidence

The companion now uses a new Swift-based gRPC server (CompanionLib/SwiftServer) that provides structured call telemetry, automatic idle shutdown, and explicit retry handling for UI automation failures. Call telemetry logs method names, arguments, and durations, and allows handlers to attach size, integer, and string metrics to each call for detailed reporting. The server tracks in-flight requests and shuts down gracefully after a period of inactivity, ensuring resources are released when the companion is no longer in use. UI automation failures now include retry verdicts in gRPC error details, enabling clients to determine if a failure is safe to retry. The server also supports TLS, configurable HTTP/2 flow control, and concurrent stream limits, and cleans up Unix domain sockets on startup.

CompanionLib/SwiftServer · high confidence

The SimulatorIPC module now includes a new set of components to handle inter-process communication via Unix sockets, including IPCFrame for message framing, IPCSocket for connection management, and IPCListener for binding to socket paths. Additionally, IPCDirectoryWatch has been added to monitor directory changes using kqueue, enabling the system to detect when socket files are created or removed. These changes support more robust and extensible communication between host and simulator processes.

SimulatorIPC, SimulatorIPCTests · high confidence

A new XCTestReporterShim implementation has been added to intercept XCTest lifecycle events (suite start/finish, test case start) and emit structured JSON output via a serial dispatch queue. This shim replaces previous swizzling approaches with a dedicated reporter that parses test metadata (class names, method names, suite counts, durations) and writes standardized event dictionaries to stdout, enabling external tools to consume detailed, machine-readable test execution data.

Shims/Shimulator/TestReporterShim · high confidence

The companion server now exposes new gRPC method handlers in CompanionLib/SwiftServer/MethodHandlers to support richer device interaction and observability. Users can now query and manipulate accessibility elements (wait, tap, scroll, set value, drag) and retrieve accessibility info via dedicated handlers, while a new accessibility quiescence stream monitors app stability states. HID input is expanded to include device orientation, shake, and hinge angle controls, alongside standard touch and keyboard events. Installation operations now provide detailed telemetry, reporting payload size, stage timings (download, extract, install), and failure causes back to the client.

CompanionLib/SwiftServer/MethodHandlers · high confidence

The CompanionUtilities module now provides a suite of Swift concurrency helpers: AsyncPromise for bridging synchronous callbacks to async contexts with cancellation support, Atomic for thread-safe property access, TaskSelect for racing multiple tasks, TaskTimeout for enforcing execution deadlines, ConcurrentForEach for parallel sequence processing, FIFOStreamWriter for synchronous-to-async stream bridging, Mutex for pthread-based locking, TeardownContext for LIFO resource cleanup, and CodeLocation for source-location tracking.

CompanionUtilities · high confidence

The Configuration module introduces several new types to manage device and process interactions. ApplicationLaunchConfiguration and ProcessSpawnConfiguration now define how apps and processes are launched, including modes like foreground or relaunch. ScreenshotConfiguration allows users to specify encoding formats (PNG, JPEG, TIFF), scaling factors, and crop regions, with detailed error handling for geometry constraints. VideoStreamConfiguration provides granular control over video output, supporting codecs like H.264 and HEVC, transport formats, and rate control strategies, while also clarifying when software JPEG encoding is permitted. Additional types like InstrumentsConfiguration and TestLaunchConfiguration structure data for profiling and test execution, and TargetConfiguration now includes detailed device model and OS version metadata.

FBControlCore/Configuration · high confidence

A new end-to-end testing framework has been added to validate the idb CLI against a booted simulator. The suite exercises core capabilities including app lifecycle management, file transfers, screenshot capture, log streaming, URL opening, permission handling, and accessibility interactions. It introduces a shared companion process architecture, automated video recording with the sim-video tool, and a documentation system that generates website demos directly from passing test transcripts.

EndToEndTests · high confidence

The REPL/CLI area now provides a complete \idb-repl\ command-line interface, replacing the previous implementation. This introduces a new interactive and one-shot mode for executing Swift code against simulator, test, and app contexts, featuring a custom cross-platform line editor (supporting macOS and Linux) and a persistent gRPC stream for the REPL session. Users can now generate Markdown session reports with hidden metadata, which enables a new \replay\ subcommand to re-execute recorded runs (skipping compile failures) and supports \--realtime\ pacing. The connection layer has been updated to use gRPC Swift 2, with TLS handling moved to \CompanionDiscovery\ and restricted to macOS for TCP connections, while Unix domain sockets remain plaintext. Telemetry has been expanded to include typed metrics for code size, execution stage, and session mode.

REPL/CLI · high confidence

The SimulatorFrameworkBridge now includes a set of new runtime client libraries that expose simulator capabilities to Swift orchestration. This adds a comprehensive AccessibilityClient with a dedicated runtime interface (FBAXRuntime) for reading element attributes, performing hit-tests, and managing snapshots, alongside clients for managing delivered notifications (FBDeliveredNotificationsClient), accessing the contacts store (FBContactsStoreClient), and reading the device's physical orientation (FBDeviceStateClient). These components encapsulate private API interactions and runtime exceptions, providing a stable, typed interface for the simulator's guest services.

SimulatorFrameworkBridge/Runtime · high confidence

The Shims/Shimulator/Tools area now includes a set of new helper files that support the simulator test runner. FBDebugLog provides conditional debug logging controlled by the SHIMULATOR\_DEBUG environment variable. FBRuntimeTools adds functions to retrieve symbol pointers from arbitrary binaries and specifically from the XCTest binary, enabling runtime inspection. FBXCTestConstants centralizes test-report event keys, exit codes, and environment variable names used by the shim. XCTestCaseHelpers extracts class and method names from test cases, using language-agnostic method names where available, and parses test suite keys. XCTestPrivate declares internal XCTest and XCTestRun interfaces required for observing and manipulating test execution. XTSwizzle provides Objective-C method-swizzling helpers to intercept XCTest behavior. Together, these files form the foundational shim layer that allows the simulator to hook into, observe, and report on XCTest runs.

Shims/Shimulator/Tools · high confidence

The XCTestBootstrap/Configuration and XCTestBootstrap/Reporters directories now contain the core types for managing test execution and output. This includes CodeCoverageConfiguration for specifying coverage collection settings, FBTestConfiguration (Objective-C) for generating and managing .xctestconfiguration files, and Swift structs like TestRunnerConfiguration and XCTestRunConfiguration (with ListTestConfiguration and TestManagerTestConfiguration) to define how tests are launched and filtered. Additionally, the reporting pipeline is implemented via the XCTestReporter protocol, LogicXCTestReporter protocol, LogicReporterAdapter, and JSONTestReporter, which handle test lifecycle events, output parsing, and JSON serialization for test results.

XCTestBootstrap/Configuration · high confidence

Added three new utility files to the FBSimulatorControl/Utility module: ExitCodePolicy, which defines how exit codes from simulator tools are interpreted; SimulatorControlFrameworkLoader, which manages the loading of essential, accessibility, and Xcode frameworks on demand; and SimulatorStateError, which provides specific error types for simulator state validation failures.

FBSimulatorControl/Utility · high confidence

This change introduces a new set of Swift value transformers in CompanionLib that translate incoming gRPC requests into internal framework types and validate arguments before execution. Specifically, it adds translation logic for accessibility actions (wait, tap, scroll, set value, drag) and accessibility info queries, crash log queries and responses, file container lookups, and video/screenshot recording configurations. These transformers enforce strict validation rules—such as rejecting invalid numeric ranges, ensuring drag source and destination are distinct, and preventing incompatible format/quality combinations—thereby improving request reliability and error reporting for users interacting with the CompanionLib service.

CompanionLib/SwiftServer/ValueTransformers · high confidence

The \FBControlCore/Applications\ module now provides a cohesive API for installing applications from local paths, remote URLs, or process inputs. It introduces \InstallSource\ and \InstallOptions\ to define where an app comes from and how it should be unpacked, while \ApplicationArchive\ handles the resolution and extraction of the \.app\ bundle. The \ApplicationInstall\ extension exposes a single \install\ method that orchestrates the entire flow—downloading, extracting, and installing—while emitting \InstallProgressEvent\ callbacks to report download, extraction, and installation stages with timing and byte-count progress. Failures are now categorized into specific \InstallError\ cases (such as HTTP errors, extraction failures, or missing bundles) to allow callers to handle issues precisely. Supporting models like \BinaryDescriptor\ and \BundleDescriptor\ provide detailed metadata about the installed application, including architecture, UUID, and bundle identifier.

FBControlCore/Applications · high confidence

The video subsystem has been restructured into the Video/ directory, introducing GPU-accelerated overlay compositing (OverlayCompositor, OverlayRenderer) that supports status bars, live stats, and animated shapes (fade, translate) on recorded and streamed frames. Recordings now support QuickTime chapter tracks, written post-recording via ChapterTrackMuxer, and ensure file integrity through incremental index fragments (SimulatorVideoFileWriter) so interrupted recordings remain playable. The encoding pipeline is unified through EncodedSampleConsumer, decoupling streaming and file-writing paths, while timing accuracy is improved by anchoring media time to the actual frame capture moment (MediaOrigin) and using ContinuousClock for stats logging (PeriodicStatsLog).

FBSimulatorControl/Video · high confidence

The video recorder library now supports extracting exact clips from recordings via new ClipDimensions and ClipStaging types that handle H.264-safe dimension rounding and atomic file promotion. A new stdin command protocol (StdinCommandHandler, StdinReader) allows external tools to control the recording stream with commands like force\_keyframe, overlay updates, screenshots, and chapter markers. Video overlay capabilities are expanded with VideoBars and VideoOverlay, enabling configurable status bars (top/bottom/left/right) with padding or overlay modes, and fixing coordinate scaling for retina displays.

Tools/VideoRecorder/Library · high confidence

The private header files for the DVTiPhoneSimulatorRemoteClient framework have been removed from the repository. This deletion eliminates the local definitions for simulator session management, application specifiers, and device runtime configurations, which are no longer maintained in this location.

PrivateHeaders/DVTiPhoneSimulatorRemoteClient · high confidence

The \FBSimulatorControlNotificationAssertion\ helper class, previously used in tests to observe and assert simulator session notifications (such as start, end, and process launch/terminate events), has been removed. This eliminates the dedicated utility for verifying notification delivery in the test suite.

FBSimulatorControlTests/Utilities · high confidence

The DVTFoundation private headers have been removed from the repository. This includes the deletion of numerous service and operation classes (such as DTDKAddAppIDService, DVTAddDeviceOperation, and DVTAppIDRecord) that previously exposed internal developer portal and device management APIs.

PrivateHeaders/DVTFoundation · high confidence

The \FBSimulatorControl.xcodeproj\ directory, including the \project.pbxproj\ build settings file and the \project.xcworkspace\ workspace configuration, has been deleted. This indicates the project has moved away from the traditional Xcode project format, likely migrating to a different build system or project generation tool (such as XcodeGen), which will require users to update their build workflows accordingly.

FBSimulatorControl.xcodeproj · high confidence

The PrivateHeaders/DTXConnectionServices directory now contains the full set of Objective-C interface declarations for the DTXConnectionServices framework, including core classes like DTXConnection, DTXChannel, and DTXMessage, as well as transport implementations (DTXMachTransport, DTXSocketTransport, DTXSharedMemoryTransport) and compression utilities. A module.modulemap has been added to register this location as a Clang module, enabling build systems to import these private symbols directly via the DTXConnectionServices module name.

PrivateHeaders/DTXConnectionServices · high confidence

The CompanionLib REPL and XCTest implementation files have been moved into their own \CompanionLib/Repl\ and \CompanionLib/XCTest\ directories. This reorganization groups the REPL control logic (including \HostCommandDispatcher\, \ReplRecordingCoordinator\, and \ReplSocketClient\) and the XCTest execution infrastructure (including \IDBTestOperation\, \IDBXCTestReporter\, and \XCTestDescriptor\) into their respective modules, improving codebase structure without changing external behavior.

CompanionLib/Repl, CompanionLib/XCTest · high confidence

The idb CLI commands have been reorganized from a monolithic structure into a modular package under \idb/cli/commands/\. This change introduces a new \\_\init\\_.py\ file to manage the command registry and splits functionality into distinct modules (e.g., \accessibility.py\, \app.py\, \file.py\, \hid.py\, \instruments.py\). Users will see this as a structural improvement that supports the addition of new commands and better organization of existing ones, such as the expanded accessibility interactions, file container management, and hardware input simulations, without changing the external command-line interface.

idb/cli/commands · high confidence

Added a new set of Objective-C protocol headers (SimDeviceIOPortInterface, SimScreen, SimDisplayRenderable, etc.) and a module map for the CoreSimDeviceIO framework. These declarations reflect the migration of simulator display and IO-port interfaces from SimulatorKit to CoreSimDeviceIO in Xcode 27 (CoreSimulator 1155.4), introducing new-style per-frame callbacks (SimScreen) alongside retained old-style damage-rect callbacks for backward compatibility.

PrivateHeaders/CoreSimDeviceIO · high confidence

Added a new set of Objective-C category headers (NSArray, NSDictionary, NSError, NSFileManager, NSString, NSUserDefaults) and a module map to the PrivateHeaders/CoreSimulatorUtilities directory. These declarations mirror the implementation now located in CoreSimulator.framework/Frameworks/CoreSimulatorUtilities as of Xcode 27 (CoreSimulator 1155.4), ensuring that simulator-specific runtime methods (such as sim\_argv, sim\_envp, and simulatorDefaults) remain available to the runtime even though they are no longer referenced by idb or FBSimulatorControl.

PrivateHeaders/CoreSimulatorUtilities · high confidence

New Xcode configuration files have been added to define build settings for the Shimulator dylibs on both iOS and macOS platforms. The iOS configuration sets the deployment target to iOS 15.0 and targets the iphonesimulator SDK, while the macOS configuration sets the deployment target to macOS 12.0. Both configurations specify code signing requirements necessary for injection to function correctly.

Shims/Shimulator/Configs · high confidence

Added Objective-C header files and module map for the SimPasteboardPlus framework, which serves as the modern replacement for the removed SimDevicePasteboard API in Xcode 26.6 and later. These headers define the SimPasteboardInterface class for syncing pasteboard contents between the host and device, the SimPasteboardDelegate protocol for monitoring sync progress, and the SimPasteboardInterfaceListener for identifying the Mach service. The entry also includes the .tbd file specifying the weak-linked framework exports, enabling runtime availability checks via FBSimPasteboardInterfaceIsAvailable.

PrivateHeaders/SimPasteboardPlus · high confidence

The Forward tool now acts as a proxy for CLI commands, forwarding remaining arguments to the companion via a JSON-RPC request. This allows the companion to execute commands through idb2's ArgumentParser, returning the command's stdout and exit code to the user. The implementation supports explicit companion connections via TCP (with optional TLS) or automatic discovery, and introduces a new --idb-companion-binary flag to override the companion binary path.

Forward · high confidence

The Companion tool has been updated to require macOS 15 as its minimum deployment target and has migrated its underlying communication layer from gRPC Swift 1 to gRPC Swift 2. This change introduces new dependencies (grpc-swift-2, grpc-swift-nio-transport, grpc-swift-protobuf) and updates the build configuration to use Swift 6, which may affect compatibility with older host systems or existing build caches.

Companion · high confidence

The CompanionLib now uses a unified IDBCommandExecutor class to handle device operations, centralizing logic for app installation (from files, streams, or URLs), accessibility interactions, and screenshot capture. This change replaces fragmented command handling with a single entry point that dispatches gRPC device actions to domain commands, improving consistency and maintainability for users interacting with the companion service.

CompanionLib · high confidence

The FBControlCore/Commands module has been rewritten in Swift, replacing the previous Objective-C bridging and synchronous patterns with native async/await protocols. This change introduces a comprehensive set of command protocols—including ApplicationCommands, FileCommands, VideoRecordingCommands, and InstrumentsCommands—that expose device capabilities such as app lifecycle management, file container operations, video streaming/recording, and instrumentation tracing. The refactoring also adds a new CodesignProvider for bundle signing and CDHash verification, and updates internal types like CrashLogNotifier and CrashLogParser to align with the new asynchronous command architecture.

FBControlCore/Commands · high confidence

The FBControlCore/Utility module has been migrated from Objective-C to Swift. This change introduces new Swift-native types and protocols for core utilities, including \Architecture\ for instruction set identification, \ArchiveExtractor\ for handling archive unpacking, \BundledResources\ for locating bundled helper tools, and \ControlCoreLogger\ for logging. It also adds \DataConsumer\ and \AccumulatingBuffer\ protocols for data handling, \CollectionOperations\ for array/dictionary manipulation, and \ConcatedJsonParser\ for parsing concatenated JSON. The migration includes corresponding Objective-C headers and implementations (e.g., \ControlCoreLogger+OSLog.m\, \DataConsumer.m\) to maintain interoperability, and updates copyright headers from Facebook to Meta.

FBControlCore/Utility · high confidence

The FBDeviceControlTests test suite has been converted from Objective-C to Swift. To support this migration, a bridging header was added to expose test helpers, and the build configuration was updated to use an xcconfig file that sets target-specific settings, ensures the Info.plist path is relative to SRCROOT, and links test bundles with -all\_load to prevent the linker from dead-stripping Objective-C categories required by the test support code.

FBDeviceControlTests · high confidence

The FBSimulatorControl framework has undergone a major architectural overhaul, migrating the core implementation from Objective-C to Swift and extracting shared logic into the new FBControlCore library. This change removes numerous legacy Objective-C classes (such as FBDispatchSourceNotifier, FBProcessLaunchConfiguration, and FBSimulator) and replaces them with modern Swift equivalents. The public API has been simplified: configuration catalogs and fluent builders have been removed in favor of direct creation requests, and the entry point is now SimulatorControlBootstrap. The framework now supports newer Xcode versions (including Xcode 27's DeviceHub) and provides improved HID event transport selection (DTUHID vs Indigo).

FBSimulatorControl · high confidence

The HID layer now supports a modern input path via the \dtuhidd\ daemon (available in Xcode 27 / iOS 26+), alongside the legacy Indigo client. This change introduces a pluggable transport system (\SimulatorHIDTransport\) that negotiates between the legacy and modern paths, with new models (\DTUHIDModels\) and a dedicated connection handler (\SimulatorDTUHIDConnection\) to serialize and send touch, keyboard, button, and vendor-defined events (such as hinge and orientation) over XPC. The \SimulatorHID\ class routes input through this negotiated transport, ensuring reliable delivery with proper drain and liveness checks, while \SimulatorHIDError\ provides specific diagnostics for when the \dtuhidd\ service is unavailable or unresponsive.

FBSimulatorControl/HID · high confidence

This change adds new Swift utility components to FBDeviceControl, including a framework loader for resolving MobileDevice symbols, error types for device control and nil-device states, and a FileManager extension for temporary files. It also introduces AppleDevicectlCommandExecutor, which enables launching applications on iOS 17 devices using the xcrun devicectl command-line tool, replacing previous mechanisms for app launch operations.

FBDeviceControl/Utility · high confidence

The \CompanionUtilities/Reporting\ module now provides a cross-platform event reporting system for the open-source build, replacing previous platform-specific implementations. This includes a new \EventReporter\ protocol and an \EmptyEventReporter\ no-op default, allowing the application to function without telemetry on non-Facebook platforms. The \EventReporterSubject\ struct defines the data model for telemetry events, supporting discrete, success, and failure event types with metadata, while ensuring safe handling of duration values to prevent crashes from negative or non-finite time intervals.

CompanionUtilities/Reporting · high confidence

The test suite for FBSimulatorControl has been converted to Swift, requiring the addition of a bridging header and the migration of test doubles and utilities. To support this transition and ensure all test code is linked correctly, the build configuration now uses -all\_load to prevent the linker from dead-stripping Objective-C categories and runtime-loaded framework stubs, while also weak-linking CoreSimulator and AccessibilityPlatformTranslation. The test bundle identifier has been updated to com.facebook.FBSimulatorControlTests.

FBSimulatorControlTests · high confidence

The website source has been migrated to Docusaurus 2, introducing a new home page structure in \website/src/pages\. This includes a \index.js\ component that renders a hero section with the 'idb' title, a 'Getting Started' link, and an embedded demo video, along with corresponding scoped CSS styles in \styles.module.css\ for the hero banner and announcement bar.

website/src/pages · high confidence

The idb/utils package introduces a modernized test case base that avoids eager event loop creation, providing a \loop\ property that returns the running loop without side effects, and adds an \AsyncMock\ class for easier mocking of async functions and context managers. Additionally, the \contextlib\ module now includes a backport of \@asynccontextmanager\ to support Python 3.6, while other changes ensure compatibility with Python 3.12 by replacing deprecated \asyncio.Task.all\_tasks()\ with \asyncio.all\_tasks()\.

idb/utils · high confidence

The SimulatorFrameworkBridge now uses a new transport layer that supports both persistent shared connections and dedicated oneshot guests. Commands like notifications delivered/retrieved are now routed to a staged guest that appears as the target app (via a temporary Info.plist and hardlinked executable), ensuring the simulator's system services accept the request. Streaming accessibility data now runs on a dedicated guest with a Unix socket connection, allowing multiple frames to be received until the stream ends. The bridge binary is selected per platform (iOS vs tvOS) and shared across the simulator via a versioned socket path in the user temp directory.

FBSimulatorControl/SimulatorFrameworkBridge · high confidence

This change introduces a suite of new command classes in FBDeviceControl/Commands that provide the concrete implementations for device operations. DeviceApplicationCommands handles installing and uninstalling applications via MobileDevice's SecureInstallApplicationBundle and SecureUninstallApplication. DeviceCrashLogCommands manages crash log ingestion, querying, and pruning using the crashreportmover and crashreportcopymobile services. DeviceDebugServerCommands and DeviceDebugServer enable remote debugging by launching a debugserver on the device (for iOS versions prior to 17) and proxying LLDB connections via a TCP socket. DeviceDebugSymbolsCommands allows listing and pulling symbol files and extracting shared cache symbols. DeviceDeveloperDiskImageCommands manages mounting and unmounting developer disk images. DeviceFileCommands provides file system operations (copy, move, remove, list) via AFC connections. DeviceDiagnosticInformationCommands fetches system diagnostics, springboard icon layouts, and mobile configuration data. These classes replace previous flat or memoized command structures with dedicated, noun-scoped implementations.

FBDeviceControl/Commands · high confidence

The process-fetching and termination logic in FBControlCore/Processes has been reimplemented in Swift. Process information is now retrieved via a new ProcessFetcher class that queries the host directly, and RunningProcessInfo is now a value type (struct). Additionally, the ProcessTerminationStrategy.killProcessIdentifier method is now asynchronous, allowing callers to await process termination with configurable backoff and signal strategies.

FBControlCore/Processes · high confidence

The REPL compiler now uses a \CompilerToolchain\ protocol to resolve the Swift toolchain, Apple SDK, and target platform, allowing non-macOS platforms to provide custom implementations while macOS continues to use \xcode-select\ and \xcrun\. This change introduces support for extra compiler and linker arguments via the toolchain provider, enabling more flexible build configurations. The \ReplCompiler\ target now handles the compilation of user code into dylibs, with improved error handling and output filtering. Additionally, the \ReplSourceGenerator\ has been updated to better handle async code and auto-imported modules, ensuring that injected code can reference test bundle modules without explicit imports.

REPL/Compiler · high confidence

The wire protocol for REPL commands in the \ReplCommand\ enum has been migrated to use Swift's \Codable\ conformance, ensuring that the contract between the injected code and the companion is strictly type-checked on both sides. This change standardizes how interaction commands (such as taps, swipes, and text input) and new screenshot/recording capabilities are serialized over the wire, improving reliability and maintainability of the communication layer.

REPL/ReplProtocol · high confidence

The project license has been changed from BSD to the MIT License, and the previous PATENTS file has been removed. Additionally, a Code of Conduct based on the Contributor Covenant v1.4 has been added to establish community standards for participation.

(repo-wide) · high confidence

The XCTestBootstrap module has been restructured to move core implementation details into Swift, replacing previous Objective-C or mixed-language approaches. This change introduces new Swift-based management classes for Mac devices and launched applications, and defines a unified \Target\ protocol family to standardize how test targets are represented. The test execution logic is now organized into distinct Swift strategies (\ListTestStrategy\, \LogicTestRunStrategy\, \ManagedTestRunStrategy\) that handle test listing and execution via a new \XCTestRunner\ protocol. Additionally, consumer-facing types have been renamed to drop the \FB\ prefix, and internal process-fetching and architecture handling have been consolidated into Swift utilities.

XCTestBootstrap/Strategies · high confidence

The Framebuffer module has been restructured to use a new, event-driven architecture for capturing simulator display updates. This change introduces dedicated types for tracking framebuffer statistics, filtering duplicate surface changes, and managing the lifecycle of display surface attachments via an async stream. Screenshot generation is now handled by a new \SimulatorImage\ actor and \SurfaceImageGenerator\ class, which render IOSurfaces to CGImages using Core Image with sRGB color space support and configurable cropping/scaling. The underlying surface registration logic now supports both new-style SimScreen callbacks and legacy IOSurface callbacks, ensuring compatibility across different CoreSimulator versions. Additionally, the module has been renamed from FB prefix to standard naming conventions for consumer-facing types.

FBSimulatorControl/Framebuffer · high confidence

The simulator control interface has been restructured from flat, free functions into a set of distinct, typed command types (e.g., \SimulatorDisplayCommands\, \SimulatorAccessibilityCommands\, \SimulatorApplicationCommands\) organized under specific nouns like \display\, \accessibility\, and \application\. This change introduces a more structured API where operations are grouped by domain, improves type safety through specific error enums (such as \SimulatorApplicationInstallError\ and \SimulatorAudioError\), and adds new capabilities like reading and setting physical orientation, managing audio settings, and handling accessibility translations with display-specific routing. The refactoring also includes internal improvements like moving process fetching to Swift and dropping the \FB\ prefix from consumer-facing types, resulting in a cleaner and more maintainable command surface.

FBSimulatorControl/Commands · high confidence

The simulator control logic in FBSimulatorControl/Strategies has been reorganized into distinct, focused strategy classes to improve modularity and maintainability. New files include DefaultsModificationStrategy and PreferenceModificationStrategy for handling plist and preference modifications, SimulatorBootStrategy and SimulatorBootVerification for managing the boot process and verifying readiness, SimulatorDeletionStrategy and SimulatorEraseStrategy for device removal and data erasure, SimulatorInflationStrategy for syncing simulator instances with available devices, SimulatorNotificationUpdateStrategy for handling state change notifications, SimulatorProcessSpawnStrategy for launching processes on simulators, and SimulatorShutdownStrategy for safe shutdown operations. This refactoring consolidates related functionality, simplifies the public API by removing the FB prefix from consumer-facing types, and provides clearer separation of concerns for simulator lifecycle management.

FBSimulatorControl/Strategies · high confidence

The video cadence logic has been reorganized from a monolithic structure into distinct, single-purpose files to improve maintainability and safety. This change introduces \StrictTimer\ to replace standard sleep mechanisms, ensuring precise frame timing by opting out of OS timer coalescing. It also adds \CadenceStats\ for logging performance metrics like push duration and overruns, and splits the frame triggering logic into \FrameCadence\ for eager mode and \LazyFrameTriggers\ for lazy mode, all while replacing unsafe concurrency markers with \OSAllocatedUnfairLock\ for better thread safety.

FBSimulatorControl/Video/Cadence · medium confidence

The video capture implementation has been restructured to replace the previous class-cluster approach with distinct, per-format sinks (BGRA, JPEG, H.264) managed by a new \DeviceCaptureFormat\ enum. This change introduces a more robust lifecycle model for \DeviceVideoStream\, using an enum-based state machine under a lock to strictly manage the transition from idle to starting, streaming, and stopped phases. Additionally, the system now explicitly handles screen-capture device permissions and configures \AVCaptureVideoDataOutput\ settings based on the selected format, ensuring that unsupported formats (like HEVC) are correctly rejected during configuration.

FBDeviceControl/Video · high confidence

Simulator creation and configuration now rely on a runtime index built from CoreSimulator metadata rather than static device and OS release catalogs. Users can create simulators using explicit device and runtime selectors (by identifier or name), with the system automatically resolving to the newest compatible runtime if none is specified. The default boot configuration now verifies that the simulator is usable before completing the boot operation, and available configurations are dynamically derived from the currently installed CoreSimulator runtimes and device types.

FBSimulatorControl/Configuration · high confidence

The build configuration has been split into distinct files (Debug.xcconfig, Release.xcconfig, Shared.xcconfig, Framework.xcconfig) to separate concerns. The minimum supported macOS version is now 15.0. Debug builds are optimized for speed with no optimization and assertions enabled, while Release builds now apply standard optimizations (-Os/-O), strip debug symbols into dSYMs, and hide private symbols to reduce binary size. Framework targets use versioning to prevent duplicate symbol errors when distributed independently. Strict compiler warnings are enabled across all configurations.

Configuration · high confidence

The accessibility subsystem in FBControlCore has been reorganized into dedicated files to improve clarity and maintainability. Key changes include the introduction of \AccessibilityDocument.swift\ for core data structures like \AccessibilityFrame\ and \AccessibilityScreenInfo\, \AccessibilityKeys.swift\ for standardized key definitions, and \AccessibilityLegacyRendering.swift\ for backward-compatible output formatting. The \AccessibilityRequestOptions.swift\ file now centralizes filtering logic, specifically implementing rules to drop zero-size elements and those wholly outside the screen when using the \--filter interactable\ option. Additionally, \AccessibilityProfile.swift\ and \AccessibilityResponse.swift\ enhance profiling and response structures to include more detailed timing and metadata, such as backend-specific performance metrics and modal information.

FBControlCore/Accessibility · high confidence

The iOS target management interface has been restructured to use a unified \Target\ protocol that combines informational properties (\TargetInfo\) and operational capabilities (\TargetCommand\). Operations are now accessed through specific 'noun' properties (e.g., \target.application\, \target.lifecycle\, \target.debugServer\) rather than direct methods on the target, allowing for more granular capability exposure. The \erase\ operation is now a direct method on the \Target\ protocol. Additionally, a new \TargetCommandCache\ class manages command instance caching with thread-safe resolution, and \TargetSet\ provides a delegate-based interface for monitoring target additions, removals, and updates.

FBControlCore/Management · high confidence

The FBSimulatorControl/Management module has been rewritten in Swift, replacing the previous Objective-C implementation. This change introduces native Swift concurrency (async/await) for simulator lifecycle operations, including creation, shutdown, deletion, and application termination. Key components like \SimulatorControlBootstrap\, \SimulatorSet\, and \Simulator\ now handle device set resolution, simulator inflation, and state notifications using modern Swift patterns, while error handling is centralized in new Swift enums (\SimulatorServiceContextError\, \SimulatorSetError\). This provides a more robust, thread-safe, and idiomatic API for managing iOS simulators.

FBSimulatorControl/Management · high confidence

The new TestLoadingShim in the Simulator shim layer changes how XCTest bundles are executed: instead of running immediately, it now waits for the host application to finish launching before invoking \\_XCTestMain\. It also improves compatibility with Xcode 13+ by explicitly searching for and loading \XCTest.framework\ from \DYLD\_FALLBACK\_FRAMEWORK\_PATH\ if the standard dynamic loader fails, and ensures test identifiers preserve the Swift module prefix for correct test listing.

Shims/Shimulator/TestLoadingShim · high confidence

The SimulatorFrameworkBridge now implements its accessibility, contacts, photos, DNS, proxy, notifications, health, and dynamic-store command orchestration in Swift. This migration introduces structured argument parsing, a quiescence tracking system for accessibility, and a unified RPC server with streaming support, providing a consistent and maintainable foundation for simulator bridge operations.

SimulatorFrameworkBridge/Swift · high confidence

The PrivateHeaders/SimulatorKit module has been updated to support Xcode 27 (CoreSimulator 1155.4). This includes adding a module map to make the headers importable as a Swift module and introducing \SimDeviceLegacyClient.h\, which provides the compile-time interface for the \SimulatorKit.SimDeviceLegacyHIDClient\ class used by SimulatorHID. Several other protocol and interface headers (e.g., \FoundationXPCProtocolProxyable\, \SimDeviceBootInfo\, \SimDeviceIOPortDescriptorState\, \SimDeviceIOProtocol\, \SimDeviceNotifier\) have been added or updated to reflect the current Xcode SDK structure.

PrivateHeaders/SimulatorKit · high confidence

The Subprocess module in FBControlCore has been restructured to use a direct posix\_spawn host engine, replacing the previous implementation. This change introduces a new \Subprocess\ struct for process specification and \FBProcessBuilder\ for configuration, allowing users to define stdin/stdout/stderr handling (including file paths, data consumers, and loggers) more flexibly. A key behavioral improvement is that captured stderr is now included in exit-code errors when a process fails, providing better diagnostic context. The engine also ensures stdout files are created with explicit permissions (0o644) and handles process termination deadlines and signal backing off to SIGKILL.

FBControlCore/Subprocess · high confidence

The XCTestBootstrapTests target has been converted to Swift, requiring the addition of a bridging header to expose XCTestConfiguration for Swift visibility and an Info.plist for bundle metadata. To ensure test-support Objective-C categories (such as FBFuture await helpers) are not dead-stripped by the linker, the build configuration now explicitly links test bundles with the -all\_load flag via OTHER\_LDFLAGS.

XCTestBootstrapTests · high confidence

The FBControlCoreTests target now uses a dedicated Info.plist and xcconfig file to manage its build settings. This change ensures that the test bundle correctly identifies itself with the com.facebook.FBControlCoreTests bundle identifier and includes private headers for testing purposes. Additionally, the linker flags have been updated to include -all\_load, which prevents the dead-stripping of Objective-C categories (such as FBFuture await helpers) that are required by the test runtime.

FBControlCoreTests · high confidence

The FBSimulatorControl XPC module now uses a single, shared connection primitive to handle all communication with the simulator. This change introduces a unified \SimulatorXPCChannel\ that manages the lifecycle, timeouts, and cancellation for both CoreDevice requests and DTUHID sends, ensuring that stream deadlines are bound to the channel and that invalid connections fail immediately. To support this, new \XPCEncoder\ and \XPCDecoder\ components provide strict, type-safe serialization for Swift \Codable\ types (including arrays, UUIDs, and scalars) over XPC, replacing previous ad-hoc encoding logic.

FBSimulatorControl/XPC · high confidence

The PrivateHeaders/CoreSimulator directory has been refreshed to align with the Xcode 27 (CoreSimulator 1155.4) API surface. This update replaces legacy class-dump headers with modern declarations and introduces \\*+Removed.h\ categories to document and preserve signatures for methods deprecated or removed in recent Xcode versions (including Xcode 8.1, 9.0, 10.0, 14, 15, and 27). Key structural changes include the migration of \SimDevice\ to use \SimDeviceBootInfo\ for boot status tracking, the removal of direct XPC request plumbing and \SimServiceConnectionManager\ in favor of \SimServiceContext\, and the deprecation of the \SimDevicePasteboard\ class in favor of the Swift-based \SimPasteboardPlus\ framework.

PrivateHeaders/CoreSimulator · high confidence

The pre-compiled test fixture applications and bundles in Fixtures/Binaries have been updated to include fresh code signatures and metadata. This includes new or refreshed CodeResources and version plists for FBTestRunnerApp, MacAppFixture, MacCommonApp, MacUnitTestFixture, MacAppUITestsFixture, TableSearch.app, iOSAppFixture, and their respective test bundles. These updates ensure the fixtures are correctly signed and compatible with the current development environment, supporting stable execution of UI and unit tests on both iOS and macOS platforms.

Fixtures/Binaries · high confidence

The video encoding subsystem has been restructured to improve reliability and correctness. H.264 and HEVC outputs are now explicitly tagged as sRGB over BT.709, ensuring players interpret colors correctly without guessing. The pipeline now uses dedicated \EncodedSampleConsumer\ implementations for MJPEG and Minicap, replacing the previous \VideoToolboxOutputMode\ abstraction. Additionally, the encoder statistics are now tracked by a dedicated \EncoderStatsRecorder\ that monitors frame outcomes, warmup periods, and bitrate starvation, providing clearer diagnostics for encoding performance.

FBSimulatorControl/Video/Encoding · high confidence

The video streaming subsystem in FBControlCore/Video has been reorganized to improve reliability and performance. Transport-specific writers (Annex-B, FMP4, MPEG-TS, MJPEG, Minicap, BGRA) are now consolidated under a unified EncodedFrameWriter protocol, allowing the system to automatically select the correct writer based on the video stream format. A new consumer backpressure mechanism prevents queue overflow by dropping frames when an asynchronous consumer exceeds a two-frame limit. Additionally, the Annex-B writer now validates AVCC length prefixes, refusing malformed samples that would otherwise cause data corruption, and the MPEG-TS writer uses a lock to safely manage metadata state.

FBControlCore/Video · high confidence

The documentation site has been migrated to Docusaurus 2 and reorganized under the fbidb.io domain. Documentation for idb and idb-repl is now nested under /docs/idb/ and /docs/idb-repl/ respectively, with automatic redirects preserving access to previous URLs. The site now supports Mermaid diagrams for visualizations, serves generated framework documentation (FBControlCore, XCTestBootstrap, FBDeviceControl, FBSimulatorControl) from READMEs, and includes recorded demos. Copyright headers and footer branding have been updated from Facebook to Meta, and the 'Support Ukraine' banner has been removed.

website · high confidence

The TestManager component of XCTestBootstrap has been ported from Objective-C to Swift, introducing a new Swift-native \TestBundleConnection\ and \TestManagerAPIMediator\ that orchestrate the test lifecycle. This rewrite includes a new \FBTestReporterAdapter\ to bridge low-level XCTest messages to the Swift reporter interface and adds robust diagnostic logic for connection failures, specifically detecting and reporting scenarios where the test host crashes and is relaunched by the OS or becomes stalled.

XCTestBootstrap/TestManager · high confidence

The XCTestBootstrap/Utility module has been fully converted from Objective-C to Swift. This change introduces modern concurrency patterns, making subprocess operations (such as xcodebuild, otool, and xcresulttool) asynchronous via async/await. It also standardizes error handling by defining specific error types (e.g., OToolDynamicLibsError, XCTestResultBundleError) and updates the logging infrastructure to use the ControlCoreLogger protocol. Public types have been renamed to drop the 'FB' prefix (e.g., FBProcessTerminationStrategy becomes ProcessTerminationStrategy), and the framework loader is now a final Swift class.

XCTestBootstrap/Utility · high confidence

The idb CLI has been refactored to use Python's asyncio for asynchronous execution, replacing the previous synchronous model. This change introduces a new command tree structure (\command\tree.py\) and base command classes (\BaseCommand\, \ClientCommand\, \ManagementCommand\, \CompanionCommand\) in \idb/cli/\\init\\_.py\, enabling better separation of concerns and plugin extensibility. The entry point (\main.py\) now handles coroutine draining and uses \asyncio.run()\. Additionally, the CLI now supports a \--reason\ flag for automation tracking, improved logging with JSON output options, and defaults the companion path to a bundled binary on macOS while disabling it on non-macOS platforms.

idb/cli · high confidence

The idb client has been rewritten to use gRPC for communication with the companion, replacing the previous protocol. This change introduces a new client architecture in the idb/grpc module, including a new Client class, a ClientManager for companion lifecycle management, and dedicated modules for handling accessibility, HID events, file operations, crash logs, video streaming, and XCTest runs over the gRPC channel.

idb/grpc · high confidence

Added build script test suite; Added comprehensive test coverage for idb CLI commands and telemetry; Added end-to-end tests for CompanionServer lifecycle and JSON-RPC handling; Added integration tests for FBControlCore subsystems; Added smoke tests for simulator display, guest services, hinge, orientation, and touchscreen commands; Added test coverage for FBDeviceControl device operations; Added test coverage for FBSimulatorControl configuration, management, and REPL components; Added test coverage for REPL session reporting, TLS, and telemetry; Added test coverage for gRPC client accessibility, HID, and file operations; Added test coverage for idb common modules; Added test coverage for the Simulator Framework Bridge accessibility service; Added test fixtures for agent and app crash reports; Added test infrastructure for smoke tests requiring a provided simulator; Added test suite for Companion Discovery logic; Added test support infrastructure for FBDeviceControl; Added test support utilities for FBControlCore; Added tests for VideoRecorder stdin protocol and clip staging; Added tests for simulator boot lifecycle and configuration; Added tests for the Shimulator protocol implementation; Added tests for the Simulator Framework Bridge Protocol; Added unit tests for CompanionLib recording, bridging, and utility components; Added unit tests for CompanionLib server components; Added unit tests for CoreDevice simulator integration; Added unit tests for FBControlCore core capabilities; Added unit tests for HID transport, event rendering, and negotiation; Added unit tests for SimulatorFrameworkBridge transport and staging logic; Added unit tests for XCTestBootstrap configuration, device management, and reporting; Added unit tests for simulator command behaviors; Added unit tests for simulator command retention and HID event handling; Added unit tests for the AXBridge accessibility subsystem; Added unit tests for video subsystem components; Expanded test support infrastructure for FBSimulatorControl; Migrated CompanionUtilities tests to Swift Testing; Removed legacy XCTest suite for simulator control and pool management.

A new empty file (.empty) has been added to the Shims/Binaries directory. This serves as a placeholder to ensure the directory is tracked by version control, likely in preparation for future binary artifacts or build outputs, though no functional behavior change is introduced by this change alone.

Shims/Binaries · high confidence

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

• CAI 63 → 63 (+0.3)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 88 → 88 (-0.7)
• Architecture 94 → 85 (-8.9)
• Maturity 66 → 66 (+0.2)
• Readiness 49 → 51 (+2.1)
• Security 79 → 82 (+3.2)
• Performance 79 (new)

• AXTranslationRequest.discoverRemoteElements (cognitive 30) (FBSimulatorControl/Commands/AXTranslationRequest.swift)
• AXTranslationRequest.discoverRemoteElements (cyclomatic 17) (FBSimulatorControl/Commands/AXTranslationRequest.swift)
• AXTreeWalk.resolveMarker (cognitive 20) (FBSimulatorControl/Commands/AXTreeWalk.swift)
• Boundary-crossing change coupling: IDBCommandExecutor.swift ↔ FBMacDevice+Commands.swift (CompanionLib/IDBCommandExecutor.swift)
• Boundary-crossing change coupling: ReplMethodHandler.swift ↔ Shared.swift (Companion/SwiftServer/MethodHandlers/ReplMethodHandler.swift)
• Boundary-crossing change coupling: SimulatorCrashLogCommands.swift ↔ SimulatorXCTestCommands.swift (FBSimulatorControl/Commands/SimulatorCrashLogCommands.swift)
• Boundary-crossing change coupling: SimulatorDapServerCommands.swift ↔ SimulatorXCTestCommands.swift (FBSimulatorControl/Commands/SimulatorDapServerCommands.swift)
• Boundary-crossing change coupling: SimulatorLocationCommands.swift ↔ SimulatorXCTestCommands.swift (FBSimulatorControl/Commands/SimulatorLocationCommands.swift)
• Boundary-crossing change coupling: SimulatorMemoryCommands.swift ↔ SimulatorXCTestCommands.swift (FBSimulatorControl/Commands/SimulatorMemoryCommands.swift)
• Boundary-crossing change coupling: SimulatorNotificationCommands.swift ↔ SimulatorXCTestCommands.swift (FBSimulatorControl/Commands/SimulatorNotificationCommands.swift)
• Change coupling clique: InstrumentsRunMethodHandler.swift, LaunchMethodHandler.swift, VideoStreamMethodHandler.swift, XctraceRecordMethodHandler.swift (Companion/SwiftServer/MethodHandlers/InstrumentsRunMethodHandler.swift)
• Change coupling: CompanionServiceProvider.swift ↔ CompanionServiceInterceptors.swift (Companion/SwiftServer/CompanionServiceProvider.swift)
• Change coupling: CompanionServiceProvider.swift ↔ LoggingInterceptor.swift (Companion/SwiftServer/CompanionServiceProvider.swift)
• Change coupling: DescribeMethodHandler.swift ↔ XCTestRunMethodHandler.swift (Companion/SwiftServer/MethodHandlers/DescribeMethodHandler.swift)
• Change coupling: DeviceApplicationCommands.swift ↔ DeviceDeveloperDiskImageCommands.swift (FBDeviceControl/Commands/DeviceApplicationCommands.swift)
• Change coupling: SimulatorApplicationCommands.swift ↔ SimulatorCrashLogCommands.swift (FBSimulatorControl/Commands/SimulatorApplicationCommands.swift)
• Change coupling: SimulatorConfiguration+CoreSimulator.swift ↔ SimulatorSet.swift (FBSimulatorControl/Configuration/SimulatorConfiguration+CoreSimulator.swift)
• Change coupling: SimulatorDapServerCommands.swift ↔ SimulatorDebuggerCommands.swift (FBSimulatorControl/Commands/SimulatorDapServerCommands.swift)
• Change-coupling hub: SimulatorLocationCommands.swift → SimulatorApplicationCommands.swift, SimulatorCrashLogCommands.swift, SimulatorDebuggerCommands.swift, SimulatorLogCommands.swift, SimulatorMemoryCommands.swift, SimulatorNotificationCommands.swift, SimulatorProcessSpawnCommands.swift, SimulatorVideoRecordingCommands.swift (FBSimulatorControl/Commands/SimulatorLocationCommands.swift)
• Change-coupling hub: SimulatorMemoryCommands.swift → SimulatorApplicationCommands.swift, SimulatorDapServerCommands.swift, SimulatorLogCommands.swift, SimulatorMediaCommands.swift, SimulatorNotificationCommands.swift, SimulatorProcessSpawnCommands.swift (FBSimulatorControl/Commands/SimulatorMemoryCommands.swift)
• …and 224 more

• AXBridgeDisplayInventory.decode (cognitive 16) (FBSimulatorControl/Commands/SimulatorDisplayInteraction.swift)
• AXBridgeDisplayInventory.decode (cyclomatic 17) (FBSimulatorControl/Commands/SimulatorDisplayInteraction.swift)
• AXBridgeUIAutomation.frontmostQuiescence (cognitive 26) (FBSimulatorControl/Accessibility/AXBridgeUIAutomation.swift)
• AXTranslationRequest.discoverRemoteElements (cognitive 33) (FBSimulatorControl/Accessibility/AXTranslationRequest.swift)
• AXTranslationRequest.discoverRemoteElements (cyclomatic 18) (FBSimulatorControl/Accessibility/AXTranslationRequest.swift)
• AXTreeWalk.resolveMarker (cognitive 20) (FBSimulatorControl/Accessibility/AXTreeWalk.swift)
• AccessibilityActionRequestTranslation.action (cyclomatic 16) (CompanionLib/SwiftServer/ValueTransformers/AccessibilityActionRequestTranslation.swift)
• AccessibilityElementFilter.keeps (cognitive 18) (FBControlCore/Accessibility/AccessibilityRequestOptions.swift)
• AccessibilityRequest.FBAXBridgeBuildNode (cognitive 47) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeBuildNode (cyclomatic 30) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeBuildTranslatorNode (cognitive 21) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeBuildTranslatorNode (cyclomatic 19) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeDispatchRequest (cognitive 56) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeDispatchRequest (cyclomatic 46) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeHitTest (cyclomatic 16) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeNodeFromSnapshot (cognitive 25) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeNodeFromSnapshot (cyclomatic 16) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeScanForAlert (cognitive 16) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityRequest.FBAXBridgeSetValue (cognitive 30) (SimulatorFrameworkBridge/Swift/AccessibilityService.swift)
• AccessibilityWaitCommand.run_with_client (cognitive 17) (idb/cli/commands/accessibility.py)
• …and 396 more

• 300 commits — 298 feature/other, 2 fixes

• FBSimulatorControlTests/Tests — 39 commits
• FBSimulatorControl/Commands — 26 commits
• FBSimulatorControl/HID — 25 commits
• CompanionLib/SwiftServer — 17 commits
• EndToEndTests/harness.py — 16 commits
• SimulatorFrameworkBridge/Swift — 16 commits
• SimulatorFrameworkBridge/Runtime — 14 commits
• FBControlCoreTests/Tests — 10 commits
• FBSimulatorControl/Accessibility — 10 commits
• idb/common — 10 commits
• EndToEndTests/accessibility_tests.py — 8 commits
• EndToEndTests/test_accessibility.py — 8 commits
• .github/workflows — 7 commits
• CompanionTests/Tests — 7 commits
• FBSimulatorControl/CoreDevice — 6 commits
• SimulatorFrameworkBridgeLibTests/AccessibilityRuntimeTests.swift — 6 commits
• idb/grpc — 6 commits
• CompanionLib/IDBCommandExecutor.swift — 4 commits
• EndToEndTests/documentation.py — 4 commits
• FBControlCore/Applications — 4 commits

• fix: Drive the accessibility tests against ReplHost's fixed screen instead of Settings
• fix: Give ReplHost a fixed screen for the accessibility tests
• change: Add a fixture whose accessibility answers block the main thread
• change: Add a harness step that denies permission prompts left on screen
• change: Add a termination deadline to Subprocess.run
• change: Add an extensible Shimulator protocol
• change: Add eject hardware button
• change: Add homebrew.py to list, install and inspect idb builds
• change: Add the install progress model
• change: Add top-level oncall or cleanup: fbcode/idb
• change: Advertise the compressions a companion can extract
• change: Allow frame reordering in clips explicitly
• change: Attribute Python telemetry at the writer
• change: Bind HID geometry to display targets
• change: Bind the AX quiescence monitor behind FBAXRuntime
• change: Bound a CoreDevice stream with the channel's deadline and cancellation
• change: Build every simulator XPC connection through one connector
• change: Build the hinge and orientation vendor reports in one place
• change: Call FBActivityRecord.from directly in its tests
• change: Capture the main screen when a display report cannot select a display
• …and 280 more

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

facebook/idb 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.