Skip to content
CAI
Software that uses CAICheck a score

facebook/idb

37.5

Weak · 14 November 2026

118.9k

lines of production code

Swift

with Python, C, Objective-C

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add AccessibilityPlatformTranslation private framework headers

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

Add CameraFixture tool and makevideo helper for camera testing

Introduces the CameraFixture command-line tool, which acts as a standalone AVFoundation capture client to stream, watch, or record camera frames and report pixel data (BGRA or YUV) for verification. It supports configuration options such as selecting the front camera via the CAMFIXTURE\_FRONT environment variable, setting session presets, and rotating video output. Additionally, a makevideo utility is added to generate test H.264 .mov files with specific color patterns, enabling controlled testing of camera rotation and input handling.

CameraFixture · high confidence

Add Mac OSX UI test fixtures

Added a new macOS application fixture (MacCommonApp) to support UI testing. This includes the main entry point and an Info.plist configuration that sets the app as a background agent (LSUIElement) and specifies a minimum macOS deployment target, licensed under MIT.

Fixtures/Source/MacCommonApp · high confidence

Add ReplHost app with privacy and accessibility test fixtures

The REPLHost application is now included in the companion distribution, serving as the default host for the \app\ REPL context. It supports on-demand privacy permission requests (camera, microphone, photos, contacts) to verify pre-approval status, and provides deterministic accessibility test fixtures: a stable UI tree for end-to-end accessibility commands and a slow-response fixture to test timeout handling.

REPLHost · high confidence

Add Swift Package Manager build support for idb-repl

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

Add idb Python client library and documentation

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

Added AXRuntime accessibility trait definitions

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

Added Mac and iOS unit test fixture bundles

New unit test fixture bundles for macOS and iOS have been added to the project. These fixtures provide a standardized set of XCTest cases to verify the runtime environment, including checks for the host platform (iOS vs. macOS), the test runner process (xctest), and specific application processes (MobileSafari vs. MacCommonApp). They also include utilities for testing asynchronous expectations, as well as controlled scenarios to simulate host process crashes and stalls via environment variables.

Fixtures/Source/MacUnitTestFixture · high confidence

Added SimulatorBridge private headers for iOS Simulator interaction

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

Added TestCrashShim for controlled crash simulation and environment logging

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 XCTestPrivate payload headers for remote automation

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 private headers for SimPasteboardPlus pasteboard API

Added Objective-C header stubs and a module map for the SimPasteboardPlus framework (introduced in Xcode 26.6+), enabling the simulator to interact with the new pasteboard synchronization API. The headers define SimPasteboardInterface for pushing and pulling pasteboard contents between the host and device, SimPasteboardDelegate for observing sync progress, and SimPasteboardInterfaceListener for identifying the Mach service, with a runtime availability check (FBSimPasteboardInterfaceIsAvailable) to support older CoreSimulator versions where the framework is absent.

PrivateHeaders/SimPasteboardPlus · high confidence

Added reverse-engineered private headers for SimulatorApp HID and GSEvent protocols

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

Added target state change notification to standard output

The Reporting module now includes a \TargetStateChangeNotifier\ that monitors target sets and writes their state changes to either a local file or standard output. When writing to stdout, it uses a new \writeToStandardOutput\ helper to bypass stdio buffers, ensuring immediate delivery of JSON-formatted target descriptions (including UDID, name, OS version, and state) to consumers.

CompanionLib/Reporting · high confidence

Autostart REPL in injected app contexts via libShimulator

The \libShimulator\ shim now includes a REPL entry point (\AppReplEntry\) that automatically starts the REPL control-socket server when the library is injected into a launched app via \DYLD\_INSERT\_LIBRARIES\. This autostart is gated by the \IDB\_REPL\_APP\_AUTOSTART\ environment variable and runs the server on a detached background thread to avoid blocking the app's main run loop. The shim also provides a Swift runtime probe (\RuntimeProbe\) that generates \.swiftinterface\ files for loaded modules, which are passed to the REPL server to provide type information. A test harness (\TestRepl\) is included to start the server in xctest contexts, and the socket server implementation (\ReplSocketServer\) handles the binary property list protocol, including support for long-lived sessions in app contexts versus single-connection sessions in test contexts.

Shims/Shimulator/Repl · high confidence

Documentation for the idb-repl interactive REPL tool

The website now includes a comprehensive documentation section for \idb-repl\, an interactive tool that allows users to run Swift code inside live iOS Simulator processes. The new pages cover the tool's architecture (driver and companion), usage across three contexts (app, simulator, test), the built-in \IDB\ API for UI automation and screenshots, and features for recording and replaying sessions via Markdown reports.

website · high confidence

IDB API introduces structured accessibility, screenshot, and video capture capabilities

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

Initial release of the idb gRPC protocol definition

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

Introduce CodesignProvider for bundle signing and CDHash retrieval

Added a new CodesignProvider class that enables signing application bundles with a specified identity and retrieving their CDHash values. The provider handles making code signature files writable before signing, executes the codesign tool, and parses the output to extract the hash, exposing these capabilities via public init, signBundle, and cdHash methods.

FBControlCore/Codesigning · high confidence

Introduce CompanionDiscovery library for managing companion processes

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

Introduce CompanionServer for local CLI command execution

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

Introduce IDBConcurrency and IDBTelemetry utility libraries

This change splits the previous CompanionUtilities into two new libraries: IDBConcurrency and IDBTelemetry. The IDBConcurrency library provides concurrency primitives for Swift, including a thread-safe AsyncPromise for bridging synchronous callbacks to async contexts, an Atomic property wrapper for safe state mutation, a FIFOStreamWriter for preserving order when bridging async streams to synchronous calls, a concurrentForEach helper, a Mutex wrapper, and utilities for task selection (Task.select) and timeouts. The IDBTelemetry library introduces an EventReporter protocol and a default no-op EmptyEventReporter implementation, along with an EventReporterSubject struct for capturing structured event data such as names, types, durations, and metadata.

IDBConcurrency, IDBConcurrencyTests, IDBTelemetry · high confidence

Introduce Mac device management and XCTest target protocols in FBXCTestCore

The FBXCTestCore/Management module now provides the foundational types for managing macOS test execution. It introduces the \MacDevice\ class, which handles local Mac target operations such as resolving the device UDID, managing auxiliary directories, and tracking installed/running applications via \BundleDescriptor\. It also adds \MacLaunchedApplication\ to represent running processes on the Mac, and defines the \XCTestTarget\, \XCTestExtendedTarget\, and \LogicTestTarget\ protocols to standardize how targets expose their XCTest capabilities and subprocess launching logic.

FBXCTestCore/Management · high confidence

Introduce Swift-based test execution and result parsing utilities

The FBXCTestCore/Utility module now provides a suite of Swift utilities for managing the test lifecycle and interpreting results. This includes XCTestLogger for structured logging to files and stderr, XCTestResultBundleParser and XCTestResultToolOperation for reading xcresult bundles and exporting attachments, and XcodeBuildOperation for launching and configuring xcodebuild test runs. Additional utilities handle crash log waiting, dynamic library resolution via otool, and runtime class allocation for private frameworks.

FBXCTestCore/Utility · high confidence

Introduce asynchronous, non-blocking socket server and stream APIs

FBControlCore/Sockets now provides a new \SocketServer\ class for listening on TCP ports and a \SocketStream\ class for handling individual client connections. The server uses \DispatchSourceRead\ to accept connections asynchronously, while the stream wrapper manages non-blocking I/O with \recv\ and \send\, supporting concurrent read and write operations. A key behavioral improvement is that cancelling a read or write operation on a \SocketStream\ now correctly reports the cancellation rather than throwing a 'bad descriptor' error, and the stream automatically closes the connection upon cancellation to unblock both directions.

FBControlCore/Sockets · high confidence

Introduce idb/common shared library with companion management, HID gestures, and plugin hooks

The \idb/common\ package is introduced as a new shared library for the idb Python client, consolidating core utilities and infrastructure. This includes a new companion management system (\Companion\, \CompanionSet\) that handles device spawning, state persistence via atomic lockfiles, and timeout configurations (e.g., 6-minute start instruments timeout). It adds support for HID-based UI gestures (swipe, tap, pinch, shake, rotate) with duration control, and a plugin framework (\plugin.py\) that allows external modules to hook into invocation lifecycle events (before/after/failed) and command parsing. Additional utilities include agent metadata parsing for coding assistants, gzip/zstd streaming for tar archives, and standardized logging with cancellation tracking.

idb/common · high confidence

Introduce new accessibility model types and profiling data structures

This change adds a comprehensive set of new model types to the FBSimulatorAX/Model module, defining the data structures for accessibility reads and diagnostics. It introduces UIAutomationBackendName to identify the backend used (ax, ax-coresimulator, axbridge variants), AccessibilityFrame and AccessibilityScreenInfo for element positioning, and AccessibilityTargetDescriptor to specify read targets (frontmost, application, point, marker). It also defines AccessibilityError for detailed error reporting, AXKeys for attribute vocabulary, and extensive profiling structures (AccessibilityProfilingData, AXBridgeProfile, AccessibilityProfilingCollector) to track timing, XPC calls, and element counts. Additionally, it adds AccessibilityModalInfo to report fullscreen alerts and AccessibilityStallObservation to capture detailed host and process activity during slow requests.

FBSimulatorAX/Model · high confidence

Introduces AXBridge as a new accessibility automation backend

Adds a new \AXBridge\ backend that communicates with an in-simulator accessibility client via the \SimulatorFrameworkBridge\ guest service. This change introduces a new read pipeline (\AXBridgeTreeReader\) and serialization logic (\AXBridgeSnapshotDecoder\, \AXTreeWalk\) to fetch and decode the accessibility tree, replacing or supplementing previous methods. It adds support for display routing, query timeouts, and typed quiescence events, enabling more reliable and performant accessibility interactions on simulators.

FBSimulatorAX/AXBridge · high confidence

Introduces FBProfilingCore for programmatic iOS profiling

Adds the FBProfilingCore module, providing a structured API for launching and managing iOS profilers. It defines configuration types for various profiling modes (leaks, heap, sample, vmmap, footprint, resources, and xctrace traces) and targets (PIDs, bundle IDs, or all processes). The module includes a ProfileOperation to manage the lifecycle of a profiling session, allowing users to start, stop, or cancel operations, and exposes results through structured report types (ProfileReport) that parse output from system tools like leaks, sample, and xctrace. It also includes a ResourceSampler for capturing periodic CPU and memory metrics.

FBProfilingCore · high confidence

Introduces FBVideoCore for unified video recording and streaming configuration

The new FBVideoCore module provides a shared, target-agnostic foundation for video capabilities, defining the \VideoTarget\ protocol and command interfaces (\VideoRecordingCommands\, \VideoStreamCommands\) that allow consumers to record to files or stream frames without depending on specific device implementations. It introduces a comprehensive \VideoStreamConfiguration\ system supporting H.264 and HEVC codecs across Annex-B, MPEG-TS, and fragmented MP4 transports, as well as MJPEG, Minicap, and raw BGRA formats, with configurable frame rates, scaling, and rate control. The module also includes a suite of \EncodedFrameWriter\ implementations to handle the low-level serialization of video samples into these various container formats.

FBVideoCore · high confidence

New CI tooling for documentation, dependency locking, and library packaging

This change introduces several new Python scripts to the CI directory to improve build reliability and distribution. A new documentation link checker validates that internal repository links in markdown and MDX files resolve correctly, handling monorepo exports and published repository layouts. Dependency locking is enforced via a tool that verifies SwiftPM resolved graphs against pinned manifests, rejecting version or revision drift. The end-to-end test suite is now organized into explicit shards (demos, UI, system, install) to allow parallel execution and isolation. Additionally, a library packaging script assembles static XCFrameworks and generates SwiftPM-compatible Package.swift manifests, including stubs for private frameworks, to support distribution via SwiftPM.

CI · high confidence

New CoreDevice transport layer for simulator display, hinge, and motion capabilities

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

New FBObjCExceptionGuard library for bridging Objective-C exceptions to Swift

A new Objective-C library, FBObjCExceptionGuard, has been added to FBControlCoreObjC to safely bridge NSException instances into NSError objects. This allows Swift code to catch Objective-C exceptions that would otherwise terminate the process, providing structured error information including the exception name, user info, and call stack symbols under the FBObjCExceptionGuardErrorDomain.

FBControlCoreObjC · high confidence

New FBSimulatorCodeInjection library for Simulator REPL, audio, and camera injection

A new \FBSimulatorCodeInjection\ library is introduced, providing three core capabilities for iOS Simulator processes: a REPL for injecting and executing Swift code via a control socket, microphone injection to play audio into an app's input, and camera injection to serve video to an app's cameras. The library exposes \simulator.codeInjection\, \simulator.audioInjection\, and \simulator.videoInjection\ on the \Simulator\ object, managing the lifecycle of injected shims (\libShimulator\) and control sockets for applications, the simulator's guest bridge, and logic test bundles.

FBSimulatorCodeInjection · high confidence

New FBSimulatorXCTest library for running XCTest bundles on iOS Simulators

A new library, FBSimulatorXCTest, has been added to provide simulator-specific test execution capabilities. It conforms the Simulator to FBXCTestCore's LogicTestTarget, allowing test runners to drive a Simulator in the same way they drive a device or local Mac. The library supports both application/UI tests (connecting to the Simulator's testmanagerd over a unix socket) and logic tests (spawning the xctest binary directly). It exposes commands for running tests, listing tests in a bundle, and launching subprocesses, while ensuring that consumers uninterested in testing do not need to link the core test framework.

FBSimulatorXCTest · high confidence

New IDBCommandExecutor centralizes companion command handling

The CompanionLib now includes a new IDBCommandExecutor class that serves as the central dispatcher for device commands. This executor exposes methods for installing applications with detailed event reporting, performing accessibility actions (tap, describe, wait, scroll, quiescence), managing processes, and handling debug server sessions. It consolidates logic previously scattered across handlers into a single, type-safe command execution layer, supporting both simulator and device targets with specific error handling for simulator-only operations.

CompanionLib · high confidence

New SimulatorFrameworkBridge transport layer and guest staging for watchOS

This change introduces the \SimulatorFrameworkBridge\ transport infrastructure within \FBSimulatorServices\, enabling host-to-guest communication via Unix sockets for services like accessibility, notifications, and lock-screen control. It adds a \SimulatorFrameworkBridgeOneshotTransport\ for single-use commands and a \SimulatorFrameworkBridgePersistentTransport\ for long-lived connections, while introducing a staging mechanism that allows the guest binary to masquerade as specific app bundle identities (required for notifications). Additionally, the bridge now ships a dedicated watchOS-simulator guest binary, selected automatically based on the simulator's product family.

FBSimulatorServices/SimulatorFrameworkBridge · high confidence

New Swift async utilities for polling, timeouts, and queue execution

FBControlCore introduces a new set of asynchronous utilities to improve control over waiting and execution. The \AsyncEvent\ class allows multiple callers to wait for a single outcome, supporting cancellation, ignoring cancellation, and timed waits via \PollTimeoutError\. The \pollUntilTrue\ function enables polling conditions with configurable intervals and deadlines, while \DispatchQueue.perform\ provides a safe way to execute non-Sendable or throwing work on specific queues from async contexts. Additionally, the \withTimeout\ helper allows operations to be bounded by a deadline, throwing a specified error if exceeded.

FBControlCore/Async · high confidence

New Unix socket IPC framework for host-simulator communication

The SimulatorIPC module now includes a new set of Swift components to manage communication between the host and simulator processes. This introduces IPCDirectoryWatch for monitoring directory changes via kqueue, IPCFrame for defining message framing and error handling, and IPCSocket for handling Unix socket connections, including listener binding with file locking and frame-based read/write operations. These changes provide the underlying infrastructure for reliable, framed message exchange over Unix domain sockets.

SimulatorIPC · high confidence

New XCTestReporterShim for structured test event reporting

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

New command types for simulator display, application, audio, and system services

This change introduces a suite of new command types in FBSimulatorControl/Commands to manage simulator capabilities and interactions. DisplayCommands and related types (RoutedDisplay, DisplayConfigurationFollower) provide detailed control over simulator displays, including handling multiple integrated displays, hinge transitions, and accessibility/touchscreen routing. SimulatorApplicationCommands handles app installation, launching, and termination with specific error handling. SimulatorAudioCommands allows reading and setting audio volume and ringer state. Additional command types include LaunchCtlCommands for managing launchctl services, SimulatorBootstrapPortCommands for Mach port lookups, SimulatorCapabilities for querying device features like hinge angle and motion, SimulatorContactsCommands for managing the Address Book, SimulatorCrashLogCommands for crash log management, SimulatorDapServerCommands and SimulatorDebugServerCommands for debugging support, and SimulatorContactsCommands for contacts management.

FBSimulatorControl/Commands · high confidence

New crash log ingestion and notification system

The FBControlCore/Crashes module now provides a new mechanism for detecting and handling application crashes. CrashLogNotifier polls for new crash logs and ingests them into a CrashLogStore, which notifies listeners via CrashLogListener when a matching log appears. CrashLogParser extracts structured data (such as bundle ID, process name, and exception details) from both macOS 12+ JSON-based and older plain-text crash formats, while CrashLogPredicate allows filtering logs by criteria like process identifier or simulator UDID.

FBControlCore/Crashes · high confidence

New download subsystem with disk spooling and connection overrides

The FBArtifactStaging/Downloads module has been replaced with a new implementation that writes incoming download data directly to a temporary file (spool) rather than holding it in memory, improving stability for large artifacts. This new system introduces a \ConnectionOverride\ mechanism that allows downloads to be routed to a specific IP address and port while maintaining TLS verification against the original URL host, enabling testing against local servers. It also includes a custom \HTTPResponseReader\ for handling HTTP/1.1 responses (including chunked encoding) over raw Network framework connections, and provides detailed \DownloadReport\ structures containing certificate chain information and connection metrics.

FBArtifactStaging/Downloads · high confidence

New end-to-end test suite for idb

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

New guest-backed commands for simulator contacts, health, lock screen, network, and privacy

This change introduces a new \FBSimulatorServices\ module that adds guest-backed commands to the \Simulator\ type, allowing control over simulator state that \simctl\ cannot reach. The new commands include managing contacts (replacing/clearing the database), HealthKit authorizations (granting/revoking/listing/clearing), lock screen state (locking/unlocking via SpringBoard), network configuration (HTTP proxy and DNS resolvers), privacy permissions (TCC services and deeplink schemes), and notification management (sending push notifications and listing/clearing delivered notifications). These commands run the \SimulatorFrameworkBridge\ helper inside the simulator, with the connection held per simulator to avoid repeated startup costs. Also in this area: 1 commit (0 fixes) modifying FBSimulatorBridgeProtocol, FBSimulatorServices, SimulatorFrameworkBridge.

FBSimulatorServices/Commands · low confidence · unverified

New idb-repl CLI with session reporting, replay, and cross-platform support

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

New in-process archive extraction library with streaming support

The FBArtifactStaging/Archives module introduces a new library for handling archive staging, featuring in-process extraction for zip and tar streams alongside traditional subprocess-based extraction via bsdtar. This change adds support for detecting and extracting zstd-compressed archives (including zstd-wrapped zips) which were previously unsupported by the system tar, and implements a streaming pipeline that can unpack archives directly from byte sources without requiring full file spooling for all formats. The library includes new error types for creation and extraction failures, a format detection system based on file headers, and parallel file writing to improve extraction performance.

FBArtifactStaging/Archives · high confidence

New sim-video CLI for recording, streaming, and terminal viewing of simulator video

The \sim-video\ command-line tool is introduced to provide direct control over simulator video capture and display. It includes four subcommands: \record\ to capture the active simulator display to local files (supporting MP4, MOV, and WebM containers with H.264, HEVC, or MJPEG encoding), \stream\ to output encoded video frames to a file or stdout for external consumption, \clip\ to extract precise, independently playable segments from existing recordings by re-encoding, and \terminal\ to render a live, color-coded view of the simulator screen directly within the terminal. The tool supports overlay controls for status bars and provides detailed recording reports. Also in this area: Introduce SimScope, an experimental macOS simulator app; New sim-video CLI for local simulator video recording and streaming with overlay controls.

Tools · high confidence

New simulator test-shim utilities for debugging, runtime inspection, and test reporting

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

New staging and end-to-end install benchmarks with automated regression checks

The Benchmarks directory now includes \staging-bench\ to measure archive staging throughput (fetch, decompress, extract) across various sources, formats, and file shapes, and \install\_bench\ with end-to-end tests to verify install patterns against a companion process. A new \floor.py\ utility enforces a minimum throughput floor (20 MB/s) for nightly CI runs to catch severe regressions on noisy hosted runners, while \staging-bench ab\ provides a stricter per-commit comparison gate. These additions provide measurable performance baselines for the archive pipeline and installation flow.

Benchmarks · high confidence

New staging-bench benchmark tool for archive staging throughput

A new \staging-bench\ command-line tool has been added to the \Benchmarks/StagingBench\ directory to measure the throughput of the artifact staging pipeline. It supports generating test fixtures of varying sizes and compression formats (such as IPA, tar, and zstd), feeding archives through multiple sources (local path, HTTP, streams, and pipes), and comparing performance metrics like throughput, CPU usage, and peak memory between different builds to detect regressions.

Benchmarks/StagingBench · high confidence

New terminal video recording pipeline with GPU-accelerated sampling and stdin control

The simulator video recording capability now includes a new pipeline that captures terminal output by sampling the simulator's BGRA framebuffer on the GPU via Metal, converting it into ANSI frames (supporting both half-block and ASCII render modes), and writing them to stdout. This pipeline is controlled via a JSON command protocol on stdin, allowing users to dynamically add overlays, toggle status bars, take screenshots, insert chapters, and force keyframes. It also handles clip staging and promotion to ensure atomic file writes, and resolves video bar configurations (padding vs. overlay modes) to correctly reserve screen space for status information.

FBSimulatorVideo/Recorder · high confidence

New utility components for device control and developer disk image management

The FBDeviceControl/Utility module now includes several new Swift components: AppleDevicectlCommandExecutor handles launching applications via the devicectl CLI and returns the process ID; DeveloperDiskImage provides logic to locate, validate, and select the best matching developer disk image and symbols for a target iOS version; DeviceControlFrameworkLoader loads the MobileDevice framework and resolves its AMDevice call table; CollectionOperations offers utilities for filtering JSON-serializable collections; and DeviceNilError defines a shared error type for deallocated device scenarios.

FBDeviceControl/Utility · high confidence

Simulator camera injection via virtual camera shim

Apps running in an armed iOS simulator can now have their camera feed replaced by a video file. This change introduces a guest-side shim in \libShimulator-iOS\ that swizzles AVFoundation methods to synthesize a virtual camera (\AVCaptureDevice\, \AVCaptureSession\, etc.) when the \IDB\_VIDEO\_INJECTION=1\ environment variable is set. The shim intercepts camera enumeration and session configuration, serving video frames from a file (with optional front/back camera distinction) via a Unix socket protocol. It supports standard AVFoundation outputs like \AVCaptureVideoDataOutput\, \AVCapturePhotoOutput\, and \AVCaptureMovieFileOutput\, handling frame scaling, orientation, and looping to match the app's expected camera behavior.

Shims/Shimulator/VideoInjection · high confidence

Simulator microphone audio injection support

Developers can now inject audio files into the microphone input of apps running in the iOS simulator using the \idb audio inject\ command. This change adds a shim that intercepts CoreAudio HAL calls to provide a synthetic audio input stream, allowing apps to receive injected WAV audio regardless of whether the host machine has a physical microphone. The feature is opt-in per process via the \IDB\_AUDIO\_INJECTION\ environment variable and is automatically enabled for app launches managed by idb.

Shims/Shimulator/AudioInjection · high confidence

Removals

Removal of DVTiPhoneSimulatorRemoteClient private headers

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

Removal of FBSimulatorControlNotificationAssertion test utility

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

Removed DVTFoundation private headers

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

Removed legacy Xcode project and workspace files

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

Removed legacy Xcode scheme for FBSimulatorControl

The manual Xcode scheme file (FBSimulatorControl.xcscheme) has been deleted from the project. This change removes the explicit build, test, and launch configurations defined in the legacy scheme, indicating a shift away from manual Xcode project management (likely towards XcodeGen or other build system automation).

FBSimulatorControl.xcodeproj/xcshareddata · high confidence

Architecture

Exposes DTXConnectionServices private headers for Clang module consumption

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

idb CLI commands restructured into a modular package

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

Behavioural changes

1 commit (0 fixes) modifying ZstdDecompress

A change to existing behaviour in ZstdDecompress — 1 commit, 1 file: “Prevent stale literal leaks after output buffer wraps”. Also in this area: Vendored Zstandard v1.5.7 decompressor library.

ZstdDecompress · medium confidence · unverified

11 commits (0 fixes) modifying Shims/ShimulatorTests

A change to existing behaviour in Shims/ShimulatorTests — 11 commits, 5 files: “Shimulator: an idle capability that reports when a process is idle”; “Add the Shimulator video capability”; “Synthesise a virtual camera from a video file”; and 8 more.

Shims/ShimulatorTests · medium confidence · unverified

2 commits (0 fixes) modifying CompanionLib/Accessibility

A change to existing behaviour in CompanionLib/Accessibility — 2 commits, 1 file: “Move the companion's accessibility commands into CompanionAccessibility”; “Measure quiescence from inside the app with the Shimulator backend”.

CompanionLib/Accessibility · medium confidence · unverified

2 commits (0 fixes) modifying Fixtures/Source/CodeInjectionPayload

A change to existing behaviour in Fixtures/Source/CodeInjectionPayload — 2 commits, 1 file: “Smoke-test that a recording's sound is level and in step with its picture”; “Add FBSimulatorCodeInjection smoke tests”.

Fixtures/Source/CodeInjectionPayload · medium confidence · unverified

4 commits (0 fixes) modifying FBSimulatorAX/IdleSync

A change to existing behaviour in FBSimulatorAX/IdleSync — 4 commits, 3 files: “Shimulator quiescence: report handled input as touches\_completed”; “Shimulator quiescence: name scrolling as a busy signal”; “Shimulator quiescence: name ignored input as a busy signal”; and 1 more.

FBSimulatorAX/IdleSync · medium confidence · unverified

4 commits (0 fixes) modifying Shims/Shimulator/IdleSync

A change to existing behaviour in Shims/Shimulator/IdleSync — 4 commits, 7 files: “Shimulator: an idle capability that reports when a process is idle”; “Shimulator idle sync: scrolling, delayed main-thread work and input”; “Shimulator idle: stop tracking delayed main-thread work”; and 1 more.

Shims/Shimulator/IdleSync · medium confidence · unverified

5 commits (1 fix) modifying Shims/Shimulator/Protocol

A change to existing behaviour in Shims/Shimulator/Protocol — 5 commits (1 fix), 3 files: “Shimulator: an idle capability that reports when a process is idle”; “Add an extensible Shimulator protocol”; “Measure quiescence from inside the app with the Shimulator backend”; and 2 more.

Shims/Shimulator/Protocol · medium confidence · unverified

6 commits (0 fixes) modifying FBSimulatorAX/UIAutomation

A change to existing behaviour in FBSimulatorAX/UIAutomation — 6 commits, 6 files: “Shimulator quiescence: name scrolling as a busy signal”; “Shimulator quiescence: name ignored input as a busy signal”; “Lay out FBSimulatorAX by backend, role and subsystem”; and 3 more.

FBSimulatorAX/UIAutomation · medium confidence · unverified

7 commits (0 fixes) modifying FBSimulatorVideo/Commands

A change to existing behaviour in FBSimulatorVideo/Commands — 7 commits, 3 files: “Replace the SimulatorVideo factory with its initialiser”; “Lay out FBSimulatorVideo's remaining root files by subsystem”; “Keep a Simulator alive while it records”; and 4 more.

FBSimulatorVideo/Commands · medium confidence · unverified

Accessibility bridge implementation moved to Swift

The SimulatorFrameworkBridge's accessibility service has been rewritten in Swift, replacing the previous Objective-C implementation. This change introduces typed request and answer models, a new quiescence tracking system for monitoring application responsiveness, and support for streaming accessibility settings and hit-test results over Unix sockets. Users will see improved serialization performance and more precise error reporting for accessibility interactions, including better handling of automation mode and display-scoped operations.

SimulatorFrameworkBridge · high confidence

Add iOS 17.0 and macOS 12.0 build configurations for Shimulator

New Xcode configuration files have been added to define build settings for the Shimulator dylibs on iOS 17.0 and macOS 12.0. These configs set the appropriate deployment targets, SDK roots, and code-signing identities, enabling the guest bridge, ReplHost, and Repl shim to be built and injected for these specific platform versions.

Shims/Shimulator/Configs · high confidence

Added CoreSimDeviceIO private headers for Xcode 27 simulator display protocols

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 CoreSimulatorUtilities header declarations for Xcode 27 compatibility

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

CLI commands are now executed through the idb-forward companion

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

Commands API migrated to Swift async protocols

The command interfaces in FBControlCore/Commands have been rewritten to use native Swift async/await patterns, replacing the previous asynchronous execution model. This change updates all command protocols—including ApplicationCommands, FileCommands, LogCommands, and ScreenshotCommands—to expose async throwing methods, allowing callers to use standard Swift concurrency for operations like launching applications, managing file containers, and capturing screenshots.

FBControlCore/Commands · high confidence

Companion server telemetry, error mapping, and graceful shutdown

The CompanionLib/SwiftServer now provides structured per-RPC telemetry that logs method names, arguments, and durations, while allowing handlers to attach custom size and metadata columns to call reports. Error handling has been standardized via ErrorMapping, which converts internal errors into descriptive gRPC status codes and carries UI automation retry verdicts in error details. The server also implements graceful shutdown with a configurable timeout to drain in-flight RPCs, an idle monitor to auto-exit when no requests are active, and improved HTTP/2 flow control to optimize large data transfers like installs.

CompanionLib/SwiftServer · high confidence

CompanionLib utility layer refactored into Swift with new streaming and storage capabilities

The CompanionLib/Utility module has been rewritten in Swift, introducing a new unified target resolution system (CompanionTarget) that abstracts device, simulator, and Mac targets behind a VideoTarget capability, and a new IDBLogger that fans out logs to multiple sinks with thread-safe global logger management. The diff adds in-process zstd and gzip stream compression support, advertised via CompanionInfo, and a new MultisourceFileReader that handles streamed archive extraction and file-path payloads through a staging layer. Storage management is now handled by IDBStorageManager, which supports saving bundles with architecture checks and optional library relocation, while process termination and RPC stream handling are improved via ProcessTermination (async process exit waiting) and RequestStreamReader (single-iterator stream consumption to prevent concurrent read errors).

CompanionLib/Utility · high confidence

Convert FBDeviceControlTests to Swift

The test suite for FBDeviceControl has been migrated from Objective-C to Swift. This change includes the addition of a bridging header to expose test helpers and a new Info.plist configuration for the test bundle, enabling the use of Swift for writing and maintaining device control tests.

FBDeviceControlTests · high confidence

FBSimulatorControl framework restructured and migrated to Swift

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

GPU-accelerated overlay compositing with letterboxing and animated effects

The simulator video pipeline now composites UI overlays (bars, labels, shapes) directly onto video frames using Core Image and Metal on the GPU. This change introduces letterboxing, ensuring that when a recording's screen shape differs from the canvas, the screen is scaled and centered with black bars rather than distorted. It also adds support for animated overlay effects (fade-in, fade-out, and translation) and allows bars to be rendered in either 'pad' mode (opaque, pushing the screen away) or 'overlay' mode (semi-transparent, allowing screen content to peek through).

FBSimulatorVideo/Overlay · high confidence

Improved error reporting for accessibility bridge failures

The accessibility bridge now provides specific, descriptive errors for common failure modes, such as when the guest binary is unavailable, the accessibility reader cannot bind, the frontmost application cannot be resolved, or an application fails to respond within the timeout. This replaces generic failures with clear messages that help diagnose issues with simulator accessibility interactions.

FBSimulatorControl/SimulatorFrameworkBridge · high confidence

Improved simulator display handling and screenshot rendering

The Framebuffer module now automatically follows the simulator's active display, ensuring that consumers like screenshot capture remain attached to the correct screen even when the layout moves or displays change. Screenshot generation has been updated to render samples as sRGB and apply interface orientation transformations directly within the Core Image pipeline, resulting in correctly oriented and color-accurate images. Additionally, the system now deduplicates surface change events to prevent redundant processing and provides periodic logging of frame-rendered and surface-change statistics for performance monitoring.

FBSimulatorControl/Framebuffer · high confidence

Introduce DTUHID transport for modern simulator input

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

Introduce Swift-native binary and bundle descriptors for application inspection

The application inspection layer now uses new Swift structs—BinaryDescriptor, BundleDescriptor, and InstalledApplication—to model app metadata. BinaryDescriptor parses Mach-O headers to expose architecture, UUID, and rpath information, while BundleDescriptor wraps bundle metadata and handles rpath updates and re-codesigning during relocation. InstalledApplication combines bundle details with install type classification (system, user, enterprise, etc.), providing a structured, type-safe view of installed applications without relying on Objective-C interop or static factory methods.

FBControlCore/Applications · high confidence

Introduce dedicated artifact staging library with unified install and progress reporting

The artifact staging logic has been moved into a new, dedicated library (\FBArtifactStaging/Staging\) to decouple installation workflows from their implementation details. This change introduces a unified \Staging\ entry point that handles downloading, extracting, and installing various artifact types (applications, test bundles, frameworks, dylibs, and dSYMs) from local paths, remote URLs, or byte streams. Users benefit from consistent, granular progress reporting via \InstallEvent\ (covering download, extract, and install stages) and structured error handling through \InstallError\, which allows callers to distinguish between HTTP failures, extraction issues, and missing artifacts. The staging layer now spools downloads to disk to manage memory usage and selects the archive extractor based on the file's initial bytes, ensuring reliable handling of compressed archives.

FBArtifactStaging/Staging · high confidence

Introduce typed accessibility bridge protocol with stable client identification

The FBSimulatorBridgeProtocol library now defines a structured, typed accessibility bridge protocol that replaces ad-hoc JSON handling with explicit Swift types. This change introduces stable, named client types (such as VoiceOver, XCTest, and Accessibility Inspector) to ensure consistent identification of accessibility requests across the host-guest boundary. It also standardizes accessibility traversal strategies (view hierarchy, semantic, single fetch) and frontmost resolution methods, while sharing a common attribute and role vocabulary between the host and guest to improve reliability and reduce ambiguity in accessibility data exchange. Also in this area: 1 commit (0 fixes) modifying FBSimulatorBridgeProtocol, FBSimulatorServices, SimulatorFrameworkBridge; Removes default nil value for explainedBy in BridgeAXNode.

FBSimulatorBridgeProtocol · low confidence · unverified

Introduces precise frame cadence control for simulator video recording

The simulator video pipeline now includes a dedicated cadence subsystem that ensures frames are pushed at precise intervals, addressing timing drift and latency issues. This change introduces a strict timer mechanism that bypasses OS timer coalescing to maintain accurate frame deadlines, a drift-corrected clock for eager-mode recording, and a lazy trigger system for variable-frame-rate scenarios that respects display refresh rates. Additionally, new statistics tracking monitors push durations, overruns, and jitter to provide visibility into recording performance.

FBSimulatorVideo/Cadence · high confidence

MobileDeviceAPI exposed as a Swift module

The MobileDevice private headers are now accessible via a dedicated module (MobileDeviceAPI) instead of a bridging header. This change introduces AMDefines.h, which defines the core types, enums, and function pointers for the AMDevice API, and a module.modulemap that exposes the umbrella header, allowing Swift code to import and use these low-level device connection and service functions directly.

PrivateHeaders/MobileDeviceAPI · high confidence

Modernized async testing utilities and Python 3.12 compatibility fixes

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

Native Swift process fetching and termination in FBControlCore

The FBControlCore/Processes module now implements process querying and termination directly in Swift, replacing previous implementations. A new ProcessFetcher class handles low-level process discovery using sysctl and proc\_listallpids, exposing methods to retrieve RunningProcessInfo (now a struct containing PID, launch path, arguments, and environment), check process states (running, stopped, debugger attached), and wait for debugger attachment or stop signals. A new ProcessTerminator class manages process termination with configurable signal strategies, including options to verify process existence before signaling, wait for process disappearance, and back off to SIGKILL if initial signals fail. The public API has been simplified by dropping the FB prefix from these core types.

FBControlCore/Processes · high confidence

New Swift-native device command implementations in FBDeviceControl/Commands

This change introduces a new set of Swift-native command types for device management, replacing the previous Objective-C-based or factory-based patterns. The new files define protocols and implementations for developer disk image mounting, application installation and uninstallation, crash log ingestion and pruning, debug server proxying, debug symbol pulling, and file container operations. These commands are now built using initializers rather than factory methods, and they expose specific capabilities through typed protocols (e.g., DeveloperDiskImageCommands, DeviceApplicationCommands, DeviceCrashLogCommands). The implementation moves process fetching and device state management into Swift, uses async/await for service connections and file operations, and provides more granular error types for each command domain.

FBDeviceControl/Commands · high confidence

New Translation layer for CompanionLib accessibility, recording, and profiling requests

This change introduces a new \Translation\ directory in \CompanionLib/SwiftServer\ containing dedicated request-translation modules for accessibility actions and info, crash logs, file containers, profiling, video recording, screenshots, and video streaming. These modules validate incoming gRPC requests, map wire formats to internal framework types (such as \UIAutomationBackend\, \VideoEncodeOptions\, and \ProfileConfiguration\), and handle error reporting, ensuring that client requests are correctly interpreted and that invalid inputs are rejected with specific error messages.

CompanionLib/SwiftServer/Translation · high confidence

New XCTest execution and reporting infrastructure

The CompanionLib/XCTest module has been restructured to support a new, async-driven test execution model. Users can now run logic, application-hosted, and UI tests via the new \XCTestRunRequest\ and \IDBTestOperation\ types, which manage test lifecycles and cancellation through Swift \Task\ objects. The module introduces \XCTestDescriptor\ to handle test bundle setup and configuration, and \IDBXCTestReporter\ to stream test results and logs back to the client. Additionally, the new \CodeCoverageRequest\ and \XCTestRunFileReader\ types enable code coverage collection and proper resolution of \xctestrun\ file paths for test environments.

CompanionLib/XCTest · high confidence

New stall observation and host activity tracking for accessibility reads

The accessibility translation layer now monitors slow requests by observing host and simulator CPU activity. New files in the Translation directory implement AXHostActivity to snapshot host processes and attribute CPU time to specific simulators, AXStallProbe and AXStallWatch to detect requests that exceed a 250ms baseline delay and record detailed thread-level usage during the wait, and AXReadCancellation to allow synchronous transport waits to be interrupted by task cancellation. These changes provide visibility into why accessibility reads stall without altering the functional outcome of the reads themselves.

FBSimulatorAX/Translation · high confidence

REPL compiler environment and toolchain resolution refactored

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

REPL host commands now map to IDBCommandExecutor and manage screen recordings

The CompanionLib REPL now executes host commands (such as taps, swipes, text input, and accessibility queries) by dispatching them through the IDBCommandExecutor interface, ensuring consistent behavior with other IDB operations. Additionally, the REPL session now includes a dedicated ReplRecordingCoordinator that manages screen recordings, allowing users to start, stop, and retrieve video artifacts during a REPL session while handling lifecycle events like app exits or session teardowns.

CompanionLib/Repl · high confidence

REPL protocol adopts Codable for type-safe command serialization

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

Re-license project to MIT and add Code of Conduct

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

Refactor CompanionLib configuration and install destination models

The CompanionLib/Configuration module has been restructured to improve modularity and clarity. New types have been introduced to manage specific configuration aspects: IDBPortsConfiguration now handles gRPC connection targets (TCP or Unix domain sockets), debug ports, and TLS settings; IDBAppHostedTestConfiguration manages test launch and code coverage settings; and DsymInstallLinkToBundle defines how dSYM files are linked to bundles. The InstallDestination enum has been updated to explicitly support these new configuration options, allowing for more granular control over artifact installation (e.g., debuggable apps, signed test bundles, and dSYM linking). Additionally, global configuration state is now centralized in IDBConfiguration with a dedicated event reporter.

CompanionLib/Configuration · high confidence

Refactor companion RPC handlers into modular Swift files with improved telemetry and streaming

The companion's RPC method handlers have been reorganized into distinct, modular Swift files (e.g., AccessibilityActionMethodHandler, InstallMethodHandler) to improve testability and code organization. This change introduces granular telemetry for accessibility reads, logging round-trip counts, element counts, and timing metrics. It also enhances the install process by streaming progress updates for app installations and providing detailed failure reporting for URL and stream-based installs. Additionally, the accessibility quiescence stream now properly handles client disconnection, and device port forwarding is exposed with strict port allow-listing and chunk size limits.

CompanionLib/SwiftServer/MethodHandlers · high confidence

Refactor test reporting into Swift protocols with an Objective-C compatible adapter

The test reporting system in FBXCTestCore has been restructured to use Swift protocols (XCTestReporter and LogicXCTestReporter) instead of concrete classes, exposing only the necessary callbacks to Objective-C via a new LogicReporterAdapter. This adapter parses JSON event data from test runs and maps them to the protocol methods, while introducing TestExceptionInfo to capture detailed failure information (message, file, line) and ActivityRecord for tracking test activities. Users benefit from a cleaner, more modular reporting interface that supports better integration with external test managers and provides richer failure context.

FBXCTestCore/Reporters · high confidence

Refactor test runners to use new class-based and enum structures

The test runner infrastructure in FBXCTestCore/Runners has been restructured to improve clarity and initialization patterns. ListTestStrategy and LogicTestRunStrategy are now ListTestRunner and LogicTestRunner classes, while ManagedTestRunStrategy is now a caseless ManagedTestRunner enum. The CompositeDataConsumer class has been renamed from FBCompositeDataConsumer, and the DataBuffer class has been renamed from FBDataBuffer and merged into a single file. Initialization has been standardized across several components: TestRunnerConfiguration, BundleDescriptor, XCTestLogger, and DataBuffer now use initializers instead of factory methods. The waiting-for-debugger reporter callback no longer uses the 'with' prefix, and the logic test runner now uses DispatchQueue.perform for reporting. XCTestProcess is now a caseless enum, and the Strategies/ directory has been retired.

FBXCTestCore/Runners · high confidence

Refactored build configuration into Debug, Release, and Shared xcconfig files

The build configuration has been restructured to separate shared settings from configuration-specific overrides. A new Shared.xcconfig file now holds common compiler warnings, language standards, and deployment targets (macOS 15.0), while Debug.xcconfig and Release.xcconfig provide distinct optimization, stripping, and assertion settings. This change ensures that Debug builds remain fast and unoptimized for development, while Release builds are properly optimized and stripped, preventing the previous behavior where Release binaries inherited Debug characteristics.

Configuration · high confidence

Refactored simulator utilities into new Swift modules

The FBSimulatorControl/Utility codebase has been reorganized into several new Swift files, introducing dedicated helpers for CoreSimulator completion handling, Objective-C runtime class instantiation, periodic stats logging, framework loading, Darwin notification observation, and simulator defaults management. This change also adds specific error types for weak target deallocation, simulator state validation, and defaults operations, while consolidating exit code policies for in-simulator tools.

FBSimulatorControl/Utility · high confidence

Refactored simulator video encoding pipeline with warm encoder pooling and retry logic

The video recording pipeline in FBSimulatorVideo has been restructured to improve reliability and performance. A new FramePusherPool keeps encoders warm for each display source, allowing streams that switch between displays to reuse existing encoders rather than incurring startup latency. The system now automatically retries hardware encoder creation with software fallback if the initial attempt is refused, preventing recording failures on hosts with intermittent hardware availability. Additionally, the pipeline now tracks detailed encoder statistics, including warmup duration, frame drops, and starvation warnings, providing better diagnostics for encoding issues.

FBSimulatorVideo/Encoding · high confidence

Refactored simulator video recording and streaming into a decoupled pipeline

The video subsystem has been restructured to separate the encoding pipeline from output destinations. A new \EncodedSampleConsumer\ protocol and \SimulatorVideoStream\ actor now drive the framebuffer-to-encoder pipeline, routing frames to either a streaming byte consumer or a file writer. This enables the \SimulatorVideo\ recorder to support MP4, MOV, and WebM containers, with WebM specifically allowing the recording to follow screen size changes during rotations. Additionally, a \ChapterTrackMuxer\ has been introduced to add QuickTime chapter tracks to finished MP4/MOV recordings, and a \MediaOrigin\ struct provides accurate media time zero timestamps anchored to the first captured frame.

FBSimulatorVideo/Stream · high confidence

Refactored video capture to use format-specific sinks and explicit lifecycle management

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. Also in this area: Refactor device activation state coercion and symbol resolution naming.

FBDeviceControl/Video · high confidence

Replaced simulator configuration and creation logic with CoreSimulator metadata

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

Reworked configuration types and added ARM64 executable thinning

The configuration layer has been refactored to use new Swift value types, including ApplicationLaunchConfiguration for managing launch modes and output streams, ScreenshotConfiguration for defining capture parameters, and InstrumentsConfiguration for timing and template settings. A new ArchitectureProcessAdapter enables launching applications on ARM64 hosts by thinning universal binaries to the required architecture and fixing dynamic library paths. Additionally, DisplaySelection allows targeting specific simulator displays, and XCTestShimConfiguration handles the discovery and validation of test shims.

FBControlCore/Configuration · high confidence

Reworked iOS target management API with capability-based access and async details

The iOS target management interface has been redesigned to improve clarity and performance. Operations are now accessed through specific capability nouns (such as \application\, \debugServer\, \lifecycle\, and \power\) rather than generic target nouns, providing a more structured way to interact with device features. Expensive target details are now read asynchronously via a new \details(\_:)\ method that supports granular keys like diagnostics and displays, replacing previous synchronous or less specific retrieval methods. Additionally, target comparison and identification have been optimized to match directly by UDID instead of using NSPredicate, and the erase operation is now a direct method on the target rather than a separate noun.

FBControlCore/Management · high confidence

Reworked test configuration and launch APIs in FBXCTestCore

The test configuration and launch logic in FBXCTestCore has been refactored to improve initialization and modularity. The \FBTestConfiguration\ type is now \TestConfiguration\, and \XCTestBootstrap\ has been renamed to \FBXCTestCore\. Configuration preparation no longer relies on separate factory methods; instead, \TestRunnerConfiguration\ and \BundleDescriptor\ are initialized directly, and \TestRunnerConfiguration.prepareConfiguration\ has been replaced by a dedicated initializer. The \CodesignProvider.cdHashForBundle\ method was renamed to \cdHash(ofBundleAtPath:)\. Additionally, \TestLaunchConfiguration\ and \XCTestCommands\ have been moved into this core module, and \FBControlCore\ is now imported locally where used rather than through public headers.

FBXCTestCore/Configuration · high confidence

Rewrote device management and activation logic in Swift

The FBDeviceControl/Management module has been rewritten in Swift, replacing the previous Objective-C implementation. This change introduces new Swift-native managers (AMDeviceManager, AMRestorableDeviceManager) for discovering and tracking connected devices, and consolidates device operations like activation and erasure into Swift extensions (Device+Activation, Device+Erase). The core Device class now caches target information and manages underlying MobileDevice or RestorableDevice references, while DeviceSet coordinates notifications from both sources to maintain a unified view of attached devices.

FBDeviceControl/Management · high confidence

Rewrote device service clients in Swift with improved connection safety

The service clients in FBDeviceControl/Services (including AMDeviceServiceManager, DeviceLinkClient, InstrumentsClient, ManagedConfigClient, and SpringboardServicesClient) have been rewritten in Swift from their previous Objective-C implementations. This change introduces a new LockdownServiceConnection that handles async invalidation with a drain timeout to prevent use-after-free crashes, and adds stricter validation for device link replies to fail safely on short responses rather than crashing. Users benefit from more robust service connections and clearer error reporting for operations like house arrest, profile management, and icon layout.

FBDeviceControl/Services · high confidence

Simulator management rewritten in Swift with async/await and explicit lifecycle control

The FBSimulatorControl/Management module has been migrated from Objective-C to Swift, introducing a modern concurrency model and clearer lifecycle management. Users now interact with simulators through a new \SimulatorControlBootstrap\ entry point and a \Simulator\ class that implements the \Target\ protocol, replacing the legacy \FBSimulatorControl\ class. Simulator creation and deletion are now explicit asynchronous operations on \SimulatorSet\, and launched applications are managed via \SimulatorLaunchedApplication\, which provides a \waitForTermination()\ method that correctly distinguishes between normal process exits and explicit termination requests. The underlying subprocess spawning has been replaced by \SimulatorSubprocessLauncher\, and simulator state changes are now observed asynchronously via \CoreSimulatorNotifier\, allowing callers to wait for state transitions without blocking threads.

FBSimulatorControl/Management · high confidence

Simulator profiling commands moved to FBSimulatorProfiling

The simulator profiling commands have been moved into the FBSimulatorProfiling module, exposing them via a new \profile\ property on the \Simulator\ type. This change allows consumers to access profiling capabilities (such as leaks, heap, and sample analysis) without linking the profiling code if they do not need it.

FBSimulatorProfiling · high confidence

Simulator test loading shim now waits for app launch and handles XCTest framework loading

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

SimulatorKit headers updated for Xcode 27 compatibility

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

Subprocess execution engine replaced with new async API

The subprocess handling in FBControlCore has been completely rewritten to use a new \Subprocess\ struct and \posix\_spawn\-based \HostSubprocess\ engine. This introduces a modern async API with \Subprocess.run\ for synchronous execution with timeouts and exit policies, \Subprocess.launch\ for managing long-running processes via \RunningSubprocess\ handles, and \Subprocess.stream\ for backpressured output consumption. The new system supports configurable standard input via \InputSource\, diverse output capture modes (string, data, file, FIFO, logger), and robust termination handling that escalates to SIGKILL after a grace period.

FBControlCore/Subprocess · high confidence

TestManager layer rewritten in Swift with improved connection diagnostics

The TestManager component of FBXCTestCore has been rewritten in Swift, replacing the previous Objective-C implementation. This change introduces a new \TestBundleConnection\ that manages the DTX transport and proxy channels, and a \TestManagerAPIMediator\ that orchestrates the test session lifecycle. A key behavioral improvement is the addition of explicit diagnostics for connection failures: the system now distinguishes between host crashes, stalls, and UI testing initialization failures, and will explicitly fail the test run if UI testing fails to initialize after the bundle is ready. The new code also provides more detailed error descriptions for connection issues, such as identifying when a host application has been relaunched by the OS or has stalled.

FBXCTestCore/TestManager · high confidence

Unified XPC transport layer for simulator communication

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

Unified accessibility automation with configurable backends and timing

Accessibility reads and actions on simulators now use a unified \uiAutomation\ API that supports multiple backends (AXBridge, CoreSimulator, and direct accessibility) with configurable persistence and display selection. The system introduces explicit timing controls for query timeouts, improved error reporting for unresponsive services, and detailed stall observation for slow requests. Users can now configure output formats (flat, nested, complete), apply element filters (all, interactable), and perform substring matches with case-insensitivity options. The implementation also adds support for remote process content sampling with grid-based hit-testing and provides better diagnostics for SpringBoard restarts and display transitions.

FBSimulatorAX/Commands · high confidence

Updated CoreSimulator private headers for Xcode 27 compatibility

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

Updated test bundle identifier

The bundle identifier for the FBSimulatorControlTests target has been changed from the dynamic variable format to the explicit string 'com.facebook.FBSimulatorControlTests'.

FBSimulatorControlTests · high confidence

Utility module ported to Swift with new concurrency and logging primitives

The FBControlCore/Utility module has been fully ported from Objective-C to Swift, introducing a modern, thread-safe logging system (ControlCoreLogger) with configurable stderr and debug output, and a new DataConsumer protocol for handling binary streams. This change adds robust asynchronous file I/O via DescriptorReader and FileWriter, a configurable BundledResources resolver for locating helper tools, and new concurrency primitives like AsyncLatch and DataBuffer to manage data flow and lifecycle events safely across queues.

FBControlCore/Utility · high confidence

idb CLI rewritten with asyncio and new command architecture

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

idb client implementation migrated to gRPC

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

idb-companion now requires macOS 15 and gRPC Swift 2

The Companion tool has been updated to require macOS 15.0 as its minimum deployment target and has migrated its underlying communication layer from gRPC Swift 1 to gRPC Swift 2 (version 2.4.3). This change introduces new dependencies for the gRPC stack and updates the project configuration to reflect the stricter system requirements and the new library versions.

Companion · high confidence

Test coverage

2 commits adding/updating tests in CompanionLibTests/Tests/Unit/SwiftServer/Translation; 3 commits adding/updating tests in Shims/ShimulatorProtocolTests; 4 commits adding/updating tests in FBSimulatorAXTests/Tests/Unit/IdleSync; 73 commits adding/updating tests in idb/grpc/tests; Add end-to-end test harness and documentation generation tooling; Added Equatable conformance for DescriptorReader.Outcome in tests; Added Equatable conformance for screenshot configuration types in tests; Added Swift Testing suite for FBSimulatorBridgeProtocol accessibility and wire contracts; 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 CodesignProvider behavior; Added integration tests for DeviceSet construction; Added integration tests for FileContainer commands; Added integration tests for ProcessFetcher; Added integration tests for Subprocess lifecycle, input, output, and streaming; Added integration tests for descriptor/file I/O and framework symbol loading; Added integration tests for socket server and stream behavior; Added smoke tests for FBSimulatorCodeInjection; Added smoke tests for accessibility tree reading and translation backends; Added smoke tests for simulator hinge and touchscreen commands; Added test coverage for FBSimulatorServices commands and bridge transport; Added test coverage for FBXCTestCore test runner and configuration logic; Added test coverage for REPL session reporting, TLS, and telemetry; Added test coverage for idb common modules; Added test coverage for the Simulator Framework Bridge accessibility service; Added test fixtures for FBProfilingCore; 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 doubles and helpers for FBSimulatorAX; Added test support infrastructure for FBSimulatorControl; Added test support infrastructure for mocking device interactions; Added test support utilities for FBArtifactStaging; Added test support utilities for Mac install harnessing and RPC response collection; Added test support utilities for logging and fixtures; Added tests for ArchitectureProcessAdapter behavior; Added tests for EventReporterSubject duration handling; Added tests for FBSimulatorXCTest command retention and socket path resolution; Added tests for SimulatorConfiguration boot validation; Added tests for recording delivery and failure handling; Added tests for simulator boot configuration and lifecycle; Added tests for simulator profiling smoke tests and command utilities; Added tests for the accessibility wire contract constants; Added unit tests for BinaryDescriptor and BundleDescriptor application logic; Added unit tests for Companion gRPC method handlers; Added unit tests for CompanionLib translation, payload extraction, and reporting; Added unit tests for CompanionLib utility components; Added unit tests for CoreDevice simulator integration; Added unit tests for FBArtifactStaging archive operations; Added unit tests for FBSimulatorAX configuration and model logic; Added unit tests for FBSimulatorAX translation and stall-probing components; Added unit tests for FBSimulatorVideo subsystems; Added unit tests for FBVideoCore video writers and configuration; Added unit tests for Framebuffer, FollowingFramebufferSurface, and SurfaceImageGenerator; Added unit tests for HID transport, event rendering, and operation logic; Added unit tests for JSON-serializable collection filtering; Added unit tests for MultisourceFileReader and StreamCapabilities; Added unit tests for ObjCRuntimeClass, PeriodicStatsTimer, and SimulatorDefaults; Added unit tests for ProcessTerminator; Added unit tests for REPL control socket and host startup error handling; Added unit tests for ReplRecordingCoordinator; Added unit tests for SimulatorAccessibilityCommands; Added unit tests for Subprocess launcher, environment handling, and termination status decoding; Added unit tests for TargetCommandCache and Target ordering; Added unit tests for XCTest operation lifecycle and code coverage export; Added unit tests for XCTestRunRequest factory and IDBCommandExecutor install flows; Added unit tests for XPC serialization and connection error handling; Added unit tests for async utilities; Added unit tests for companion server method handlers; Added unit tests for companion server telemetry, idle monitoring, and RPC cancellation; Added unit tests for crash log handling components; Added unit tests for device command implementations; Added unit tests for device command retention and transient storage; Added unit tests for device management and video capture helpers; Added unit tests for device service communication and control components; Added unit tests for download spooling, backpressure, and report generation; Added unit tests for gRPC request translation logic; Added unit tests for simulator code injection internals; Added unit tests for simulator command behaviors; Added unit tests for simulator command retention and HID event handling; Added unit tests for simulator configuration and runtime resolution; Added unit tests for simulator management components; Added unit tests for the AXBridge accessibility subsystem; Added unit tests for the FBArtifactStaging module; Added unit tests for transient FBControlCore models; Added unit tests for utility components in FBControlCore; Added unit tests for video stream format handling and byte contracts; Migrate IPC tests to Swift Testing; Migrate configuration unit tests to Swift Testing; Removed legacy XCTest suite for simulator control and pool management.

Dependencies

93 commits updating dependencies (7 manifests)

A dependency / build maintenance change in (dependencies) — 93 commits (7 fixs), 7 files: “Bump website dependencies to fix GitHub vulnerability warnings”; “Pin protobuf version”; “Bump brace-expansion from 5.0.5 to 5.0.6 in /website (\#925)”; and 84 more (refs \#925, \#603, \#613, \#939, \#963, …).

(dependencies) · high confidence · unverified

Housekeeping

Added placeholder for Shims/Binaries directory; Added test bundle Info.plist for FBControlCoreTests.

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

How this codebase got here

Score

  • CAI 37 → 38 (+0.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 67 → 82 (+14.5)
  • Architecture 96 → 96 (+0.2)
  • Maturity 75 → 74 (-0.6)
  • Readiness 51 → 51 (-0.4)
  • Security 84 → 78 (-6.3)
  • Event-Driven 10 → 10 (+0.0)
  • Performance 62 → 60 (-2.1)

Resolved (63)

  • AXNode.init (cognitive 29) (Tools/SimScope/SimScope/AXTree.swift)
  • AXNode.init (cyclomatic 20) (Tools/SimScope/SimScope/AXTree.swift)
  • AgentDispatcher.perform (cognitive 22) (Tools/SimScope/SimScope/AgentDispatcher.swift)
  • AgentDispatcher.perform (cyclomatic 30) (Tools/SimScope/SimScope/AgentDispatcher.swift)
  • AppDelegate.populateSimulatorMenu (cognitive 27) (Tools/SimScope/SimScope/AppDelegate.swift)
  • Boundary-crossing change coupling: SimulatorLocationCommands.swift ↔ SimulatorNotificationCommands.swift (FBSimulatorControl/Commands/SimulatorLocationCommands.swift)
  • Boundary-crossing change coupling: SimulatorLogCommands.swift ↔ SimulatorNotificationCommands.swift (FBSimulatorControl/Commands/SimulatorLogCommands.swift)
  • Change coupling: BridgeServices.swift ↔ ServiceCommand.swift (SimulatorFrameworkBridge/Swift/BridgeServices.swift)
  • Change coupling: DeviceApplicationCommands.swift ↔ DeviceLocationCommands.swift (FBDeviceControl/Commands/DeviceApplicationCommands.swift)
  • Change coupling: SimulatorLocationCommands.swift ↔ SimulatorMemoryCommands.swift (FBSimulatorControl/Commands/SimulatorLocationCommands.swift)
  • Change coupling: SimulatorLocationCommands.swift ↔ SimulatorSubprocessLauncher.swift (FBSimulatorControl/Commands/SimulatorLocationCommands.swift)
  • ClassTooLong: DeviceWindowController (Tools/SimScope/SimScope/DeviceWindowController.swift)
  • ClassTooLong: SimulatorView (Tools/SimScope/SimScope/SimulatorView.swift)
  • Coverage.compute (cognitive 22) (Tools/SimScope/SimScope/AXTree.swift)
  • Device.cacheValues (cognitive 24) (FBDeviceControl/Management/Device.swift)
  • Device.cacheValues (cyclomatic 25) (FBDeviceControl/Management/Device.swift)
  • DeviceCatalog.connectBooted (cognitive 16) (Tools/SimScope/SimScope/DeviceCatalog.swift)
  • DeviceWindowController.openControlChannel (cognitive 23) (Tools/SimScope/SimScope/DeviceWindowController.swift)
  • DeviceWindowController.openControlChannel (cyclomatic 17) (Tools/SimScope/SimScope/DeviceWindowController.swift)
  • DeviceWindowController.populate (cognitive 16) (Tools/SimScope/SimScope/DeviceWindowController.swift)
  • …and 43 more

New (189)

  • AudioCaptureFile.record (cognitive 17) (Shims/Shimulator/AudioInjection/AudioCaptureFile.swift)
  • AudioCaptureFile.record (cyclomatic 18) (Shims/Shimulator/AudioInjection/AudioCaptureFile.swift)
  • AudioInjectionHAL.swift.keep (cognitive 21) (Shims/Shimulator/AudioInjection/AudioInjectionHAL.swift)
  • AudioInjectionHAL.swift.keep (cyclomatic 17) (Shims/Shimulator/AudioInjection/AudioInjectionHAL.swift)
  • AudioInjectionHAL.swift.trampoline (cognitive 16) (Shims/Shimulator/AudioInjection/AudioInjectionHAL.swift)
  • AudioTrackMuxer.addAudio (cognitive 23) (FBSimulatorVideo/Writers/AudioTrackMuxer.swift)
  • AudioTrackMuxer.addAudio (cyclomatic 21) (FBSimulatorVideo/Writers/AudioTrackMuxer.swift)
  • AudioTrackMuxer.copySamples (cognitive 26) (FBSimulatorVideo/Writers/AudioTrackMuxer.swift)
  • BundleBuildIdentity.readRegularFile (cognitive 17) (CompanionLib/Utility/BundleBuildIdentity.swift)
  • BundleBuildIdentity.readRegularFile (cyclomatic 16) (CompanionLib/Utility/BundleBuildIdentity.swift)
  • Change coupling: ConnectMethodHandler.swift ↔ DescribeMethodHandler.swift (CompanionLib/SwiftServer/MethodHandlers/ConnectMethodHandler.swift)
  • Client.record_video (cyclomatic 16) (idb/grpc/client.py)
  • Duplicated block (13 lines × 2) (FBDeviceControl/Management/AMDeviceManager.swift)
  • Duplicated block (14–17 lines × 2) (FBSimulatorAX/UIAutomation/UIAutomationQuiescence.swift)
  • Duplicated block (26 lines × 2) (FBVideoCore/Writers/AnnexBFrameWriter.swift)
  • Duplicated block (5 lines × 2) (FBSimulatorAX/Model/AccessibilityResponse.swift)
  • Duplicated block (5 lines × 3) (Shims/Shimulator/AudioInjection/AudioInjectionBootstrap.swift)
  • Duplicated block (7 lines × 2) (FBSimulatorAX/Model/AccessibilityProfile.swift)
  • Duplicated block (7 lines × 2) (SimulatorFrameworkBridge/Swift/DeliveredNotificationsService.swift)
  • Duplicated block (9 lines × 2) (FBDeviceControl/Services/ManagedConfigClient.swift)
  • …and 169 more

Changes since last survey

  • 70 commits — 67 feature/other, 3 fixes

By area

  • idb/grpc — 9 commits
  • FBSimulatorControl/HID — 7 commits
  • Shims/Shimulator — 6 commits
  • CompanionLib/SwiftServer — 5 commits
  • idb/cli — 5 commits
  • idb/common — 4 commits
  • REPL/CLI — 3 commits
  • (root) — 2 commits
  • FBArtifactStaging/Downloads — 2 commits
  • FBDeviceControl/Management — 2 commits
  • FBSimulatorAX/IdleSync — 2 commits
  • FBSimulatorAXTests/Tests — 2 commits
  • FBSimulatorCodeInjectionTests/Tests — 2 commits
  • FBSimulatorControl/Commands — 2 commits
  • FBSimulatorControlTests/Tests — 2 commits
  • CompanionLib/IDBCommandExecutor.swift — 1 commit
  • CompanionLibTests/Tests — 1 commit
  • EndToEndTests/harness.py — 1 commit
  • EndToEndTests/test_accessibility.py — 1 commit
  • FBProfilingCore/Reports — 1 commit

Notable commits

  • fix: Fix all remaining UseExplicitNilCheckInConditions violations
  • fix: Fix retained companion reconnects by preserving device discovery lifetime
  • fix: Fix two profile output bugs in the Python client
  • change: Add --audio to idb video
  • change: Add a client opt-in for simulator notification service extensions
  • change: Add an audio track to a simulator recording
  • change: Add explicit app-window screenshot capture providers
  • change: Add local NSE processing to SimulatorFrameworkBridge
  • change: Add opt-in screenshot application context observations
  • change: Capture and mix what a simulator's apps play
  • change: Capture what armed simulator apps play
  • change: Describe screenshot application context without inferring source
  • change: Drop the wall-clock bound from the stall-probe duration test
  • change: Expose opt-in notification service extension delivery over gRPC
  • change: Fail active DTUHID gestures after connection interruption
  • change: Group ReplSession's compile parameters into ReplCompileEnvironment
  • change: Install from the meta/fb tap
  • change: Keep applications installed from a URL extracted, and clone them on the next install
  • change: Keep reading a waited launch's output while stdout is blocked
  • change: Keep the bytes that arrive with the close when a download is cut short
  • …and 50 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit feb60fd884e2bf22f9a8cf59111e0468e9039338 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.