Port Status

Verification: Build each native backend, then run permission-granted capture checks on hardware or an interactive browser and verify a real frame and saved image.

Why it is outside the suite: A headless portability run cannot accept consent dialogs, guarantee a camera device, or compare nondeterministic sensor frames.

Verification: Use a signed permission-granted build, record a calibrated tone or voice sample, and verify duration, level, and playback on the target device.

Why it is outside the suite: Hosted runners do not provide consistent microphones and operating systems deliberately require interactive consent.

Verification: Run the AR or sensor sample on supported hardware, verify session startup and sensor updates, and compare motion against a controlled physical action.

Why it is outside the suite: Simulators do not provide a real camera pose, AR runtime, or reproducible physical movement; the automated row checks API contracts and unsupported fallbacks instead.

Verification: Install a signed build, grant the appropriate permission level, feed known routes or physically cross a geofence, and verify foreground and background callbacks.

Why it is outside the suite: The result depends on user permission, GPS/radio state, operating-system scheduling, and physical movement outside the hosted runner.

Verification: Use a signed app and real provider credentials, register a device, send from the push service, and verify foreground, background, and launch delivery.

Why it is outside the suite: Push requires certificates or provider keys, an externally reachable service, a uniquely registered installation, and asynchronous OS delivery.

Verification: Create sandbox products, sign with a store account, complete purchase and restore flows, and validate receipts against the store or Commerce backend.

Why it is outside the suite: The flow requires store-side product configuration, signed identities, sandbox accounts, payment UI, and mutable server receipt state.

Verification: Populate a device test account, grant access, exercise read/select/write operations, and verify the result in the native contacts or calendar application.

Why it is outside the suite: Access is permission-gated and the expected result lives in private user databases and native UI outside the test process.

Verification: Enroll biometrics on hardware, run success, cancellation, lockout, and enrollment-change cases, and verify protected-secret invalidation.

Why it is outside the suite: Hosted runners have no enrolled biometric hardware and native prompts are intentionally controlled by the user and secure hardware.

Verification: Present known physical tags and cards, verify payloads and errors, and use a certified reader for host-card-emulation exchanges.

Why it is outside the suite: NFC requires short-range hardware, physical tags or readers, user presentation, and platform entitlements that hosted runners lack.

Verification: Use a known peripheral or protocol simulator, scan and connect, then verify characteristic reads, writes, notifications, reconnects, and permission denial.

Why it is outside the suite: Radio state, nearby peripherals, pairing, permissions, and timing are external to the deterministic screenshot runner.

Verification: Install a signed build, configure the required modes, background or terminate it, and observe callbacks across OS throttling and restart scenarios.

Why it is outside the suite: Scheduling is deliberately nondeterministic, power-policy controlled, entitlement dependent, and often takes longer than a CI job window.

Verification: Use release-like signed builds, compromised and clean devices, fresh server nonces, and backend verification of vendor-signed verdicts.

Why it is outside the suite: Trust verdicts depend on hardware-backed keys, store-distributed builds, vendor services, device state, and an application backend.

Verification: Seed platform storage, launch the native picker, select and cancel items, and verify temporary URI or security-scoped access after returning to the app.

Why it is outside the suite: The decisive UI and permissions belong to another process, and hosted runners do not share an identical populated media or document library.

Verification: Open each native chooser or handler on a configured device, complete and cancel actions, and verify returned result metadata where the OS supplies it.

Why it is outside the suite: Installed applications, accounts, SIM capability, chooser UI, and user selection are outside the app process and differ per runner.

Verification: Use a store-eligible build and account, request the prompt under vendor quota rules, and verify fallback behavior separately.

Why it is outside the suite: Apple and Google intentionally decide whether the native prompt appears, so a request cannot deterministically assert visible store UI.

Verification: Use valid provider keys on a networked device, load known coordinates, exercise gestures and markers, and confirm provider attribution and fallback behavior.

Why it is outside the suite: Provider keys are secrets, map imagery changes independently, usage may be billed, and native peers or network tiles are not deterministic pixels.

Verification: Use provider test-unit identifiers in a signed build, complete consent flows, and verify fill, impression, click, and lifecycle callbacks.

Why it is outside the suite: Ad inventory, consent state, provider accounts, network policy, and SDK UI are external and nondeterministic; the first table uses deterministic mock ads.

Verification: Install the correctly signed app or extension, publish timelines and actions, then inspect the launcher, lock screen, Dynamic Island, notification area, or desktop host.

Why it is outside the suite: The first table checks serialization, rasterization, timelines, and dispatch, but the final surface is rendered by a separate OS process with signing and entitlement requirements.

Verification: Enable the platform screen reader, traverse representative forms, verify announcements and actions, and repeat with dynamic content and input devices.

Why it is outside the suite: The first table validates semantics and API state, while the final speech, focus order, gestures, and switch-control behavior belong to external OS services.

Verification: Compile each architecture, inspect the generated package, sign with platform credentials, install it, and exercise the integrated native entry point or SDK in its target environment.

Why it is outside the suite: These checks happen before app startup or require private signing identities, store portals, proprietary SDK credentials, and platform-specific source rather than one shared runtime assertion.