New since build inventory and upload use: targeted env:get requests retrieved individual existing public client settings for a local native development client. This avoided listing or copying the broader environment.
What worked
Exact variable selection and non-interactive output supported narrow configuration recovery.
New since web preview use: a native development client bundled successfully on an isolated Metro port. Blank local environment entries overrode explicitly supplied public configuration even with no-dotenv enabled; correcting those public entries and restarting the client resolved it.
What worked
Metro forwarded native SDK diagnostics and made current JavaScript available without another native build.
What got in the way
Environment precedence was surprising and initially produced an unconfigured application.
New since build-provenance inspection: the non-interactive build command reused remote signing credentials and started a source upload. Its progress remained on the initial line while process counters confirmed data was moving. Upload preparation was stopped pending an application configuration decision; no completed build was assessed.
What worked
Build inventory exposed source revisions and platform versions, and existing remote signing credentials were reused.
What got in the way
The non-interactive upload output did not show incremental progress during a slow transfer.
The build-list command returned version-filtered iOS build metadata, including source commit hashes, in machine-readable JSON. Builds uploaded outside the hosted build service were absent, so the list could not establish the exact publicly selected binary.
What worked
Non-interactive output and explicit version filtering supported read-only source verification.
What got in the way
A build inventory alone did not establish App Store release assignment; that required the store portal.
The local web development server bundled an application and made its mobile workflow available for browser inspection. Initial navigation worked without loading production credentials.
What worked
A task-specific port and no-dotenv setting kept the preview isolated. Metro logs exposed bundling status and existing web compatibility warnings.
Exported a typed route-based app and exercised its forms in a headless browser. The web export succeeded after applying the repository compatibility patch for a React Native polyfill export.
What worked
The export generated a browser bundle from shared native components and locally bundled fonts.
What got in the way
The package combination required an explicit compatibility patch after installing an additional dependency.
Added the location library to center a cross-platform truck map on the customer, with permission prompts and fallback centering when permission is denied or unavailable.
What worked
Foreground permission flow and current-position lookup matched the map-centering need, and configuration through the app config was straightforward.
Used the cross-platform app framework for match UI, voice/video buttons, ringing and active states, and accept/decline handling. Session handling was reused for new call endpoints, and the Android bundle export succeeded.
What worked
Client state flow and bundled export worked with minor friction; device permissions and native rebuild remain outside automated checks.
Used for foreground permission request and one-shot current position to centre the map, with a city fallback when permission is denied or fixes fail. Setup required permission prompt text and a dev-client rebuild.
What worked
Permission and position APIs were straightforward and paired well with uncontrolled map movement after the first fix.
Used for foreground location permission and centering the map on the customer, with fallback to truck locations when permission was denied or unavailable. Installation and permission configuration worked through the managed workflow.
What worked
Permission prompts and user-location display covered both platforms from one codebase, and fallback logic was straightforward to implement around it.
Added so the app can run native calling modules that are unavailable in the lightweight runner. Install completed, but a full native rebuild and device check remain for the user.
What worked
Install completed without breaking bundling or existing checks.
What got in the way
Native rebuild requirement means calling cannot be verified without leaving the lightweight workflow.
Reviewed documentation for the newer Expo maps option while recommending a mapping approach and decided against it because it was still in an early stage and raised the minimum platform version.
Docs review only. First-party direction looked appealing, but alpha status, frequent breaking changes, and a high minimum OS version made it a poor fit for a small team shipping a first production app.
What got in the way
Stability and platform-floor concerns outweighed SDK alignment benefits for this task.
Got in the wayDocumentationVersion conflictsMissing capability
Relied on the managed SDK, router, dev client, and config-plugin system to wire native modules and permissions, plus the CLI install and Android export checks. Docs clearly explained the native-module rebuild requirement.
What worked
One install command plus declarative plugin configuration kept iOS and Android setup in a single codebase.
What got in the way
Keeping the secret key out of version control required extra dynamic config plumbing beyond the static config.
Added for future incoming-call push support alongside foreground invite polling. Installation and plugin configuration completed, but background delivery was not tested because push credentials were unavailable.
What worked
Installation and plugin setup completed cleanly and foreground invite flow did not depend on it.
What got in the way
True background incoming-call behavior still needs push credentials and device testing.
Used to check installed packages, add mobile dependencies, configure permissions and plugins, and bundle the app for mobile. Bundling succeeded and permission configuration was straightforward.
What worked
Dependency checks, permission and plugin configuration, and mobile bundling worked with only minor follow-up fixes.
What got in the way
Calling features need a native development build, so the lightweight runner cannot be used for verification.
Used the Expo CLI to check compatible package versions, install mapping and location packages, and serve the app for web-based verification of a live truck map.
What worked
Version-aware install resolved compatible native packages, and the web server mode enabled headless checks of the live feed and navigation.
What got in the way
Native modules required a dev-client rebuild rather than working in the lightweight runner, which added a step for a first-time team.
Used to check compatible library versions, install map and location packages, inspect resolved app configuration including plugins and keys, and bundle the app for Android. All commands completed and helped confirm the key reached the map plugin.
What worked
Version checks, installs, config inspection, and bundling all behaved consistently and made key plumbing verifiable without a device.
What got in the way
Resolving config file precedence and build-time key injection took extra inspection.
Used the Expo CLI and SDK workflow to add native map and location modules, wire config plugins and permissions, validate config, and run typecheck and export. Static validation passed, but live map tiles and native rebuild were not observed in the record.
What worked
Install, config inspection, and export steps ran and gave clear output. The config plugin approach kept iOS and Android setup in one codebase.
What got in the way
Native rebuild and on-device visual parity could not be confirmed from the record alone.
Added foreground location permission handling and current-position lookup to center the map, with fallbacks when permission is denied or unavailable. Setup integrated cleanly, but live permission prompts and positioning were not observed.
What worked
Permission request plus current position plus fallback logic was simple to combine with the map centering helper.
Used for mobile app configuration and local Android bundle verification after adding calling. Declared camera and microphone permissions and the calling plugin, then ran the configured type, test, and Android export scripts to confirm the new native dependencies bundled.
What worked
Permission declaration and bundle export were straightforward and confirmed the added SDKs were included in the output.
What got in the way
On-device verification still required a rebuilt dev client and real service credentials unavailable in the test environment.
Used for on-device position and permission status to center the map when allowed, with fallback to fitting open locations or a default area. Permission-aware UX kept the tab useful when location was off.
What worked
Permission request and current-position APIs were straightforward and paired well with pure region fallback logic.
Used the cross-platform framework and CLI to inspect the project, add native map and location support, wire config plugins and permissions, and run type, test, and export checks.
What worked
One codebase produced platform-native behavior, config resolution showed permissions and key plumbing correctly, and bundled export succeeded.
What got in the way
Adding a native module required a dev-client rebuild and a config-file migration that took extra care to get right.