nativescript 9.1.0-alpha.2 → 9.1.0-alpha.4

package/lib/commands/prepare.js

@@ -22,6 +22,11 @@ class PrepareCommand extends command_base_1.ValidatePlatformCommandBase {
                 hasSensitiveValue: false,
             },
             hmr: { type: "boolean" /* OptionType.Boolean */, default: false, hasSensitiveValue: false },
+            skipNative: {
+                type: "boolean" /* OptionType.Boolean */,
+                default: false,
+                hasSensitiveValue: false,
+            },
             whatever: {
                 type: "boolean" /* OptionType.Boolean */,
                 default: false,

package/lib/controllers/run-controller.js

@@ -15,7 +15,7 @@ const util = require("util");
 const _ = require("lodash");
 const yok_1 = require("../common/yok");
 class RunController extends events_1.EventEmitter {
-    constructor($analyticsService, $buildController, $debugController, $deviceInstallAppService, $devicesService, $errors, $injector, $hmrStatusService, $hooksService, $liveSyncServiceResolver, $liveSyncProcessDataService, $logger, $mobileHelper, $platformsDataService, $pluginsService, $prepareController, $prepareDataService, $prepareNativePlatformService, $projectChangesService, $projectDataService) {
+    constructor($analyticsService, $buildController, $debugController, $deviceInstallAppService, $devicesService, $errors, $injector, $hmrStatusService, $hooksService, $liveSyncServiceResolver, $liveSyncProcessDataService, $logger, $mobileHelper, $platformsDataService, $pluginsService, $prepareController, $prepareDataService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $staticConfig) {
         super();
         this.$analyticsService = $analyticsService;
         this.$buildController = $buildController;
@@ -37,7 +37,10 @@ class RunController extends events_1.EventEmitter {
         this.$prepareNativePlatformService = $prepareNativePlatformService;
         this.$projectChangesService = $projectChangesService;
         this.$projectDataService = $projectDataService;
+        this.$staticConfig = $staticConfig;
         this.prepareReadyEventHandler = null;
+        this._syncInProgress = false;
+        this._pendingSyncs = new Map();
     }
     async run(runData) {
         const { liveSyncInfo, deviceDescriptors } = runData;
@@ -60,13 +63,11 @@ class RunController extends events_1.EventEmitter {
                     const platformData = this.$platformsDataService.getPlatformData(data.platform, projectData);
                     const prepareData = this.$prepareDataService.getPrepareData(liveSyncInfo.projectDir, data.platform, { ...liveSyncInfo, watch: !liveSyncInfo.skipWatcher });
                     const changesInfo = await this.$projectChangesService.checkForChanges(platformData, projectData, prepareData);
-                    if (changesInfo.hasChanges) {
-                        await this.syncChangedDataOnDevices(data, projectData, liveSyncInfo);
+                    if (!changesInfo.hasChanges) {
+                        return;
                     }
                 }
-                else {
-                    await this.syncChangedDataOnDevices(data, projectData, liveSyncInfo);
-                }
+                this.scheduleSyncOnDevices(data, projectData, liveSyncInfo);
             };
             this.prepareReadyEventHandler = handler.bind(this);
             this.$prepareController.on(constants_2.PREPARE_READY_EVENT_NAME, this.prepareReadyEventHandler);
@@ -277,6 +278,14 @@ class RunController extends events_1.EventEmitter {
                 },
                 watch: !liveSyncInfo.skipWatcher,
             });
+            // For Android + Vite HMR, own the `adb reverse` ourselves —
+            // with our SDK-resolved adb, scoped to this exact serial, and
+            // only after the device is up — then hand the bundler the
+            // result via env vars. This MUST run before `prepare` (which
+            // spawns the Vite bundler that inherits `process.env`) so the
+            // bundler trusts the tunnel instead of racing us to spawn its
+            // own adb during config-load. See packages/vite hardening.
+            await this.setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, "pre-build");
             const prepareResultData = await this.$prepareController.prepare(prepareData);
             const buildData = {
                 ...deviceDescriptor.buildData,
@@ -327,6 +336,11 @@ class RunController extends events_1.EventEmitter {
                     watch: !skipWatcher,
                     liveSyncDeviceData: deviceDescriptor,
                 });
+                // Re-establish the adb reverse on the CURRENT transport right
+                // before launch — the transport can change during build/install
+                // and drop the mapping set in `pre-build`, which would leave the
+                // app unable to reach the Vite dev server at 127.0.0.1.
+                await this.setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, "pre-launch");
                 await this.refreshApplication(projectData, liveSyncResultInfo, null, deviceDescriptor);
                 this.$logger.info(`Successfully synced application ${liveSyncResultInfo.deviceAppData.appIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}.`);
                 this.emitCore(constants_2.RunOnDeviceEvents.runOnDeviceStarted, {
@@ -353,6 +367,134 @@ class RunController extends events_1.EventEmitter {
         };
         await this.addActionToChain(projectData.projectDir, () => this.$devicesService.execute(deviceAction, (device) => _.some(deviceDescriptors, (deviceDescriptor) => deviceDescriptor.identifier === device.deviceInfo.identifier)));
     }
+    /**
+     * Set up `adb reverse tcp:<port> tcp:<port>` for an Android device
+     * when the project bundles with Vite in HMR/watch mode, then export
+     * the result to the bundler subprocess via environment variables.
+     *
+     * The Vite dev-host helper prefers an ADB tunnel (device-side
+     * `127.0.0.1:<port>` → host) over the emulator's flaky slirp NAT
+     * (`10.0.2.2`). Historically the bundler tried to wire that tunnel
+     * itself at config-load time, racing this CLI's device discovery
+     * over the single global adb daemon and intermittently freezing the
+     * run at "Searching for devices…". The CLI is the right owner: it
+     * knows the exact target serial and when the device is ready, and it
+     * already drives a single, version-matched adb. We do the reverse
+     * here and signal the bundler with `NS_ADB_REVERSE_READY=1` so it
+     * never spawns adb on its own.
+     *
+     * Best-effort: any failure is logged at trace level and swallowed.
+     * The bundler then falls back to its own (now hardened) adb path, or
+     * ultimately to `10.0.2.2`, so a reverse hiccup never fails the run.
+     */
+    async setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, phase) {
+        try {
+            if (!this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
+                return;
+            }
+            if (projectData.bundler !== "vite") {
+                return;
+            }
+            // HMR over the tunnel only matters for a live watch session.
+            if (liveSyncInfo.skipWatcher || !liveSyncInfo.useHotModuleReload) {
+                return;
+            }
+            // Respect the user's explicit opt-out — they want the
+            // `10.0.2.2` / LAN path, so don't create a tunnel or claim one
+            // exists.
+            if (this.isTruthyEnvFlag(process.env.NS_HMR_NO_ADB_REVERSE)) {
+                return;
+            }
+            // `NS_HMR_PREFER_LAN_HOST` means the dev wants LAN routing
+            // (physical device over Wi-Fi); the dev-host resolver suppresses
+            // the adb-reverse path for it, so don't bother wiring one.
+            if (this.isTruthyEnvFlag(process.env.NS_HMR_PREFER_LAN_HOST)) {
+                return;
+            }
+            const serial = device.deviceInfo.identifier;
+            const port = this.getViteHmrPort();
+            if (phase === "pre-build") {
+                // Decide the origin baked into bundle.mjs. Hand the bundler our
+                // exact adb (so any self-managed fallback can't version-mismatch
+                // the daemon) and, if the tunnel comes up, tell it to emit
+                // `127.0.0.1` and skip adb entirely.
+                process.env.NS_ADB_PATH = await this.$staticConfig.getAdbFilePath();
+                process.env.NS_DEVICE_SERIAL = serial;
+                const ok = await this.ensureAndroidReverse(device, serial, port);
+                if (ok) {
+                    process.env.NS_ADB_REVERSE_READY = "1";
+                    this.$logger.info(`Set up adb reverse tcp:${port} tcp:${port} for ${serial} (Vite HMR routes device-side 127.0.0.1:${port} through ADB).`);
+                }
+                else {
+                    this.$logger.warn(`Could not confirm 'adb reverse tcp:${port}' on ${serial} (device adbd slow/unresponsive). Vite HMR will fall back to 10.0.2.2. If this persists, cold-boot/wipe the emulator, or set NS_HMR_NO_ADB_REVERSE=1.`);
+                }
+                return;
+            }
+            // phase === "pre-launch": re-establish the mapping right before the
+            // app boots. `adb reverse` mappings are bound to the device's adb
+            // transport, and that transport can change during the (long) build
+            // + install (fresh emulators reconnect as they settle), silently
+            // dropping the early mapping. We only bother when we actually told
+            // the bundle to use `127.0.0.1` (READY set during pre-build).
+            if (!this.isTruthyEnvFlag(process.env.NS_ADB_REVERSE_READY)) {
+                return;
+            }
+            const ok = await this.ensureAndroidReverse(device, serial, port);
+            if (!ok) {
+                this.$logger.warn(`adb reverse tcp:${port} was not active before launch on ${serial}; the app may fail to reach the Vite dev server at 127.0.0.1:${port}.`);
+            }
+        }
+        catch (err) {
+            this.$logger.trace(`Setting up adb reverse for Vite HMR (${phase}) failed; leaving it to the bundler fallback. Error: ${err}`);
+        }
+    }
+    /**
+     * Apply `adb reverse tcp:<port> tcp:<port>` to the device and confirm
+     * via `adb reverse --list` that it actually landed, retrying a few
+     * times. Every device-side call is bounded with a Node `spawn` timeout
+     * + `SIGKILL` so a wedged/slow adbd (observed blocking 90s+ on some
+     * fresh-boot / API-36 arm64 emulators) can never hang the run — the
+     * hung adb child is reaped, not orphaned. Returns whether the mapping
+     * is confirmed present.
+     */
+    async ensureAndroidReverse(device, serial, port) {
+        var _a, _b, _c;
+        const adb = device.adb;
+        const ADB_WAIT_MS = 15000;
+        const ADB_REVERSE_MS = 20000;
+        const bounded = (timeout) => ({
+            deviceIdentifier: serial,
+            treatErrorsAsWarnings: true,
+            childProcessOptions: { timeout, killSignal: "SIGKILL" },
+        });
+        // `wait-for-device` only blocks until the transport is up; bounded so a
+        // never-ready device can't stall us.
+        await adb.executeCommand(["wait-for-device"], bounded(ADB_WAIT_MS));
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            await adb.executeCommand(["reverse", `tcp:${port}`, `tcp:${port}`], bounded(ADB_REVERSE_MS));
+            // Verify it landed (a SIGKILL'd-on-timeout reverse resolves rather
+            // than throws, so success of the call isn't proof).
+            const list = (_c = (_b = (_a = (await adb.executeCommand(["reverse", "--list"], bounded(ADB_WAIT_MS)))) === null || _a === void 0 ? void 0 : _a.toString) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : "";
+            if (list.includes(`tcp:${port}`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getViteHmrPort() {
+        // The Vite dev server defaults to 5173; the bundler reads the same
+        // default. If a project runs Vite on a different port, the dev sets
+        // `NS_HMR_PORT` so the CLI reverses the matching port.
+        const fromEnv = Number(process.env.NS_HMR_PORT);
+        return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 5173;
+    }
+    isTruthyEnvFlag(value) {
+        if (typeof value !== "string") {
+            return false;
+        }
+        const v = value.trim().toLowerCase();
+        return !!v && v !== "0" && v !== "false" && v !== "off" && v !== "no";
+    }
     async syncChangedDataOnDevices(data, projectData, liveSyncInfo) {
         const successfullySyncedMessageFormat = `Successfully synced application %s on device %s.`;
         const rebuiltInformation = {};
@@ -476,18 +618,13 @@ class RunController extends events_1.EventEmitter {
                 }
             }
             catch (err) {
-                this.$logger.warn(`Unable to apply changes for device: ${device.deviceInfo.identifier}. Error is: ${err && err.message}.`);
+                this.$logger.warn(`Unable to apply changes for device: ${device.deviceInfo.identifier}. Error is: ${err && err.message}. Will retry on next change.`);
                 this.emitCore(constants_2.RunOnDeviceEvents.runOnDeviceError, {
                     projectDir: projectData.projectDir,
                     deviceIdentifier: device.deviceInfo.identifier,
                     applicationIdentifier: projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()],
                     error: err,
                 });
-                await this.stop({
-                    projectDir: projectData.projectDir,
-                    deviceIdentifiers: [device.deviceInfo.identifier],
-                    stopOptions: { shouldAwaitAllActions: false },
-                });
             }
         };
         await this.addActionToChain(projectData.projectDir, () => this.$devicesService.execute(deviceAction, (device) => {
@@ -498,15 +635,65 @@ class RunController extends events_1.EventEmitter {
                 _.some(liveSyncProcessInfo.deviceDescriptors, (deviceDescriptor) => deviceDescriptor.identifier === device.deviceInfo.identifier));
         }));
     }
+    scheduleSyncOnDevices(data, projectData, liveSyncInfo) {
+        if (this._syncInProgress) {
+            const platform = data.platform;
+            const existing = this._pendingSyncs.get(platform);
+            if (existing) {
+                existing.data = this.mergeFilesChangeEvents(existing.data, data);
+            }
+            else {
+                this._pendingSyncs.set(platform, { data, projectData, liveSyncInfo });
+            }
+            return;
+        }
+        this.executeSyncOnDevices(data, projectData, liveSyncInfo);
+    }
+    async executeSyncOnDevices(data, projectData, liveSyncInfo) {
+        this._syncInProgress = true;
+        try {
+            await this.syncChangedDataOnDevices(data, projectData, liveSyncInfo);
+        }
+        catch (err) {
+            this.$logger.trace(`Error during sync on devices: ${err.message || err}`);
+        }
+        finally {
+            const nextEntry = this._pendingSyncs.entries().next();
+            if (!nextEntry.done) {
+                const [platform, pending] = nextEntry.value;
+                this._pendingSyncs.delete(platform);
+                this.executeSyncOnDevices(pending.data, pending.projectData, pending.liveSyncInfo);
+            }
+            else {
+                this._syncInProgress = false;
+            }
+        }
+    }
+    mergeFilesChangeEvents(a, b) {
+        return {
+            files: [...new Set([...a.files, ...b.files])],
+            staleFiles: [
+                ...new Set([...(a.staleFiles || []), ...(b.staleFiles || [])]),
+            ],
+            hasOnlyHotUpdateFiles: a.hasOnlyHotUpdateFiles && b.hasOnlyHotUpdateFiles,
+            hasNativeChanges: a.hasNativeChanges || b.hasNativeChanges,
+            hmrData: b.hmrData,
+            platform: b.platform,
+        };
+    }
     async addActionToChain(projectDir, action) {
         const liveSyncInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
         if (liveSyncInfo) {
-            liveSyncInfo.actionsChain = liveSyncInfo.actionsChain.then(async () => {
+            liveSyncInfo.actionsChain = liveSyncInfo.actionsChain
+                .then(async () => {
                 if (!liveSyncInfo.isStopped) {
                     liveSyncInfo.currentSyncAction = action();
                     const res = await liveSyncInfo.currentSyncAction;
                     return res;
                 }
+            })
+                .catch((err) => {
+                this.$logger.warn(`Error in action chain: ${err.message || err}`);
             });
             const result = await liveSyncInfo.actionsChain;
             return result;

package/lib/data/prepare-data.js

@@ -33,6 +33,10 @@ class PrepareData extends controller_data_base_1.ControllerDataBase {
             this.watchNative = data.watchNative;
         }
         this.hostProjectPath = data.hostProjectPath;
+        if (data.skipNative) {
+            this.nativePrepare = { skipNativePrepare: true };
+            this.watchNative = false;
+        }
         this.uniqueBundle = !this.watch && data.uniqueBundle ? Date.now() : 0;
     }
 }

package/lib/declarations.d.ts

@@ -31,7 +31,7 @@ interface INodePackageManager {
 	install(
 		packageName: string,
 		pathToSave: string,
-		config: INodePackageManagerInstallOptions
+		config: INodePackageManagerInstallOptions,
 	): Promise<INpmInstallResultInfo>;
 
 	/**
@@ -44,7 +44,7 @@ interface INodePackageManager {
 	uninstall(
 		packageName: string,
 		config?: IDictionary<string | boolean>,
-		path?: string
+		path?: string,
 	): Promise<string>;
 
 	/**
@@ -84,7 +84,7 @@ interface INodePackageManager {
 	 */
 	search(
 		filter: string[],
-		config: IDictionary<string | boolean>
+		config: IDictionary<string | boolean>,
 	): Promise<string>;
 
 	/**
@@ -130,7 +130,7 @@ interface IPerformanceService {
 		methodInfo: string,
 		startTime: number,
 		endTime: number,
-		args: any[]
+		args: any[],
 	): void;
 
 	// Will return a reference time in milliseconds
@@ -141,39 +141,39 @@ interface IPackageInstallationManager {
 	install(
 		packageName: string,
 		packageDir: string,
-		options?: INpmInstallOptions
+		options?: INpmInstallOptions,
 	): Promise<any>;
 	uninstall(
 		packageName: string,
 		packageDir: string,
-		options?: IDictionary<string | boolean>
+		options?: IDictionary<string | boolean>,
 	): Promise<any>;
 	getLatestVersion(packageName: string): Promise<string>;
 	getNextVersion(packageName: string): Promise<string>;
 	getLatestCompatibleVersion(
 		packageName: string,
-		referenceVersion?: string
+		referenceVersion?: string,
 	): Promise<string>;
 	getMaxSatisfyingVersion(
 		packageName: string,
-		versionRange: string
+		versionRange: string,
 	): Promise<string>;
 	getLatestCompatibleVersionSafe(
 		packageName: string,
-		referenceVersion?: string
+		referenceVersion?: string,
 	): Promise<string>;
 	getInspectorFromCache(
 		inspectorNpmPackageName: string,
-		projectDir: string
+		projectDir: string,
 	): Promise<string>;
 	clearInspectorCache(): void;
 	getInstalledDependencyVersion(
 		packageName: string,
-		projectDir?: string
+		projectDir?: string,
 	): Promise<string>;
 	getMaxSatisfyingVersionSafe(
 		packageName: string,
-		versionIdentifier: string
+		versionIdentifier: string,
 	): Promise<string>;
 }
 
@@ -181,8 +181,7 @@ interface IPackageInstallationManager {
  * Describes options that can be passed to manipulate package installation.
  */
 interface INodePackageManagerInstallOptions
-	extends INpmInstallConfigurationOptions,
-		IDictionary<string | boolean> {
+	extends INpmInstallConfigurationOptions, IDictionary<string | boolean> {
 	/**
 	 * Destination of the installation.
 	 * @type {string}
@@ -266,7 +265,7 @@ interface INpmPeerDependencyInfo {
 				 * @type {string}
 				 */
 				requires: string;
-			}
+			},
 		];
 		/**
 		 * Dependencies of the dependency.
@@ -550,8 +549,7 @@ interface INpmInstallConfigurationOptionsBase {
 	ignoreScripts: boolean; //npm flag
 }
 
-interface INpmInstallConfigurationOptions
-	extends INpmInstallConfigurationOptionsBase {
+interface INpmInstallConfigurationOptions extends INpmInstallConfigurationOptionsBase {
 	disableNpmInstall: boolean;
 }
 
@@ -597,7 +595,8 @@ interface ITypingsOptions {
 }
 
 interface IOptions
-	extends IRelease,
+	extends
+		IRelease,
 		IDeviceIdentifier,
 		IJustLaunch,
 		IAvd,
@@ -622,7 +621,7 @@ interface IOptions
 	argv: IYargArgv;
 	validateOptions(
 		commandSpecificDashedOptions?: IDictionary<IDashedOption>,
-		projectData?: IProjectData
+		projectData?: IProjectData,
 	): void;
 	options: IDictionary<IDashedOption>;
 	shorthands: string[];
@@ -709,6 +708,7 @@ interface IOptions
 	dryRun: boolean;
 
 	platformOverride: string;
+	skipNative: boolean;
 	uniqueBundle: boolean;
 	// allow arbitrary options
 	[optionName: string]: any;
@@ -719,26 +719,22 @@ interface IEnvOptions {
 }
 
 interface IAndroidBuildOptionsSettings
-	extends IAndroidReleaseOptions,
-		IRelease,
-		Partial<IHasAndroidBundle> {}
+	extends IAndroidReleaseOptions, IRelease, Partial<IHasAndroidBundle> {}
 
 interface IHasAndroidBundle {
 	androidBundle: boolean;
 }
 
 interface IPlatformBuildData
-	extends IRelease,
-		IHasUseHotModuleReloadOption,
-		IBuildConfig,
-		IEnvOptions {}
+	extends IRelease, IHasUseHotModuleReloadOption, IBuildConfig, IEnvOptions {}
 
 interface IDeviceEmulator extends IHasEmulatorOption, IDeviceIdentifier {}
 
 interface IRunPlatformOptions extends IJustLaunch, IDeviceEmulator {}
 
 interface IDeployPlatformOptions
-	extends IAndroidReleaseOptions,
+	extends
+		IAndroidReleaseOptions,
 		IRelease,
 		IClean,
 		IDeviceEmulator,
@@ -834,7 +830,7 @@ interface IAndroidToolsInfo {
 	 */
 	validateJavacVersion(
 		installedJavaVersion: string,
-		options?: IAndroidToolsInfoOptions
+		options?: IAndroidToolsInfoOptions,
 	): boolean;
 
 	/**
@@ -913,14 +909,14 @@ interface IAppDebugSocketProxyFactory extends NodeJS.EventEmitter {
 		device: Mobile.IiOSDevice,
 		appId: string,
 		projectName: string,
-		projectDir: string
+		projectDir: string,
 	): Promise<any>;
 
 	ensureWebSocketProxy(
 		device: Mobile.IiOSDevice,
 		appId: string,
 		projectName: string,
-		projectDir: string
+		projectDir: string,
 	): Promise<any>;
 
 	removeAllProxies(): void;
@@ -939,12 +935,12 @@ interface IiOSSocketRequestExecutor {
 	executeAttachRequest(
 		device: Mobile.IiOSDevice,
 		timeout: number,
-		projectId: string
+		projectId: string,
 	): Promise<void>;
 	executeRefreshRequest(
 		device: Mobile.IiOSDevice,
 		timeout: number,
-		appId: string
+		appId: string,
 	): Promise<boolean>;
 }
 
@@ -995,7 +991,7 @@ interface IProjectNameService {
 	 */
 	ensureValidName(
 		projectName: string,
-		validateOptions?: { force: boolean }
+		validateOptions?: { force: boolean },
 	): Promise<string>;
 }
 
@@ -1089,7 +1085,7 @@ interface IBundleValidatorHelper {
 	 */
 	getBundlerDependencyVersion(
 		projectData: IProjectData,
-		bundlerName?: string
+		bundlerName?: string,
 	): string;
 }
 
@@ -1171,7 +1167,7 @@ interface IAssetsGenerationService {
 	 * @returns {Promise<void>}
 	 */
 	generateSplashScreens(
-		splashesGenerationData: IResourceGenerationData
+		splashesGenerationData: IResourceGenerationData,
 	): Promise<void>;
 }
 
@@ -1207,7 +1203,7 @@ interface IPlatformValidationService {
 		provision: true | string,
 		teamId: true | string,
 		projectData: IProjectData,
-		platform?: string
+		platform?: string,
 	): Promise<boolean>;
 
 	validatePlatformInstalled(platform: string, projectData: IProjectData): void;
@@ -1220,7 +1216,7 @@ interface IPlatformValidationService {
 	 */
 	isPlatformSupportedForOS(
 		platform: string,
-		projectData: IProjectData
+		projectData: IProjectData,
 	): boolean;
 }
 
@@ -1228,27 +1224,27 @@ interface IPlatformCommandHelper {
 	addPlatforms(
 		platforms: string[],
 		projectData: IProjectData,
-		frameworkPath?: string
+		frameworkPath?: string,
 	): Promise<void>;
 	cleanPlatforms(
 		platforms: string[],
 		projectData: IProjectData,
-		frameworkPath: string
+		frameworkPath: string,
 	): Promise<void>;
 	removePlatforms(
 		platforms: string[],
-		projectData: IProjectData
+		projectData: IProjectData,
 	): Promise<void>;
 	updatePlatforms(
 		platforms: string[],
-		projectData: IProjectData
+		projectData: IProjectData,
 	): Promise<void>;
 	getInstalledPlatforms(projectData: IProjectData): string[];
 	getAvailablePlatforms(projectData: IProjectData): string[];
 	getPreparedPlatforms(projectData: IProjectData): string[];
 	getCurrentPlatformVersion(
 		platform: string,
-		projectData: IProjectData
+		projectData: IProjectData,
 	): string;
 }
 

package/lib/options.js

@@ -225,6 +225,7 @@ class Options {
                 default: true,
             },
             dryRun: { type: "boolean" /* OptionType.Boolean */, hasSensitiveValue: false },
+            skipNative: { type: "boolean" /* OptionType.Boolean */, hasSensitiveValue: false },
             uniqueBundle: { type: "boolean" /* OptionType.Boolean */, hasSensitiveValue: false },
         };
     }

package/lib/services/bundler/bundler-compiler-service.js

@@ -8,6 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BundlerCompilerService = void 0;
 const path = require("path");
+const net = require("net");
 const semver = require("semver");
 const _ = require("lodash");
 const events_1 = require("events");
@@ -34,6 +35,10 @@ class BundlerCompilerService extends events_1.EventEmitter {
         this.$packageInstallationManager = $packageInstallationManager;
         this.$projectConfigService = $projectConfigService;
         this.bundlerProcesses = {};
+        // Vite-only: the long-lived `vite serve` dev server the device fetches
+        // modules and HMR updates from. Keyed by platform, managed by this CLI
+        // so users no longer need a separate `concurrently`/`wait-on` process.
+        this.viteServeProcesses = {};
         this.expectedHashes = {};
     }
     getViteDistOutputPath(projectDir) {
@@ -47,6 +52,14 @@ class BundlerCompilerService extends events_1.EventEmitter {
             }
             let isFirstBundlerWatchCompilation = true;
             prepareData.watch = true;
+            // Bring up the Vite HMR dev server the device fetches modules /
+            // HMR updates from. No-op unless bundler is vite + hmr + watch.
+            // Fired in parallel with the build watcher; both child processes
+            // inherit the adb-reverse env the run-controller set before
+            // prepare, so neither one spawns adb on its own. Intentionally not
+            // awaited — the device only connects to it at app launch, well
+            // after the first build.
+            this.startViteDevServer(platformData, projectData, prepareData);
             try {
                 const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
                 // Handle Vite differently from webpack
@@ -346,6 +359,141 @@ class BundlerCompilerService extends events_1.EventEmitter {
         await this.$cleanupService.addKillProcess(childProcess.pid.toString());
         return childProcess;
     }
+    getViteHmrPort() {
+        const fromEnv = Number(process.env.NS_HMR_PORT);
+        return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 5173;
+    }
+    /**
+     * Spawn and manage the Vite dev server (`vite serve`) for HMR.
+     *
+     * Why the CLI owns this. With Vite, HMR needs a long-lived dev server
+     * (HTTP + the `/ns-hmr` websocket on port 5173) that the device fetches
+     * modules and hot updates from — it is SEPARATE from the
+     * `vite build --watch` process that emits the `bundle.mjs` bootstrap
+     * baked into the app. Historically users wired this up themselves with
+     * `concurrently`/`wait-on`, which left two uncoordinated processes both
+     * touching adb during cold start (the source of the Android
+     * "Searching for devices…" freeze). By spawning it here as a child of
+     * the CLI, the dev server inherits the CLI's environment — crucially
+     * `NS_ADB_REVERSE_READY`/`NS_DEVICE_SERIAL`/`NS_ADB_PATH` set by the
+     * run-controller — so the CLI is the single adb owner and the dev
+     * server never spawns adb itself.
+     *
+     * No-op unless bundler is vite, HMR is on, watch mode, and not release.
+     * Best-effort: failures are logged, never thrown — a dev-server hiccup
+     * must not fail the run.
+     */
+    async startViteDevServer(platformData, projectData, prepareData) {
+        try {
+            if (this.getBundler() !== "vite") {
+                return;
+            }
+            if (!prepareData.watch || !prepareData.hmr || prepareData.release) {
+                return;
+            }
+            const key = platformData.platformNameLowerCase;
+            if (this.viteServeProcesses[key]) {
+                return;
+            }
+            const port = this.getViteHmrPort();
+            // One dev server per port. Simultaneous multi-platform HMR in a
+            // single CLI invocation would collide on 5173 — that case still
+            // needs a distinct NS_HMR_PORT per platform, so skip + warn rather
+            // than fail to bind.
+            const collidingPlatform = Object.keys(this.viteServeProcesses)[0];
+            if (collidingPlatform) {
+                this.$logger.warn(`Vite dev server already running for '${collidingPlatform}' on port ${port}; skipping a second server for '${key}'. For simultaneous multi-platform HMR, set a distinct NS_HMR_PORT per platform.`);
+                return;
+            }
+            const envData = this.buildEnvData(platformData.platformNameLowerCase, projectData, prepareData);
+            const cliArgs = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
+            const additionalNodeArgs = semver.major(process.version) <= 8 ? ["--harmony"] : [];
+            if (await this.shouldUsePreserveSymlinksOption()) {
+                additionalNodeArgs.push("--preserve-symlinks");
+            }
+            // `vite serve` (not `build`): runs the dev server and watches on
+            // its own — no `--watch`. Env flags (`--env.android --env.hmr …`)
+            // go after `--` so vite's CLI doesn't choke on unknown options.
+            const args = [
+                ...additionalNodeArgs,
+                this.getBundlerExecutablePath(projectData),
+                "serve",
+                `--config=${projectData.bundlerConfigPath}`,
+                `--mode=development`,
+                "--",
+                ...cliArgs,
+            ].filter(Boolean);
+            const options = {
+                cwd: projectData.projectDir,
+                // Inherit so the dev server's URLs/logs stream to the user as
+                // before. No IPC needed here — the build watcher provides the
+                // bundle-complete IPC; the dev server is fetched over HTTP/ws.
+                stdio: "inherit",
+                env: {
+                    ...process.env,
+                    NATIVESCRIPT_BUNDLER_ENV: JSON.stringify(envData),
+                },
+            };
+            if (this.$hostInfo.isWindows) {
+                Object.assign(options.env, { APPDATA: process.env.appData });
+            }
+            this.$logger.info(`Starting Vite dev server (HMR) for ${key} on port ${port}…`);
+            const childProcess = this.$childProcess.spawn(process.execPath, args, options);
+            this.viteServeProcesses[key] = childProcess;
+            await this.$cleanupService.addKillProcess(childProcess.pid.toString());
+            childProcess.once("exit", (code) => {
+                delete this.viteServeProcesses[key];
+                if (code) {
+                    this.$logger.warn(`Vite dev server for ${key} exited with code ${code}.`);
+                }
+            });
+            // Bounded readiness probe so we surface a clear log once the
+            // device can actually reach modules (or warn if it never binds).
+            const ready = await this.waitForPort(port, 30000);
+            if (ready) {
+                this.$logger.info(`Vite dev server ready on port ${port} (HMR for ${key}).`);
+            }
+            else {
+                this.$logger.warn(`Vite dev server did not open port ${port} within 30s; HMR may be unavailable.`);
+            }
+        }
+        catch (err) {
+            this.$logger.warn(`Failed to start the Vite dev server: ${err}. HMR may be unavailable.`);
+        }
+    }
+    /**
+     * Resolve true once `127.0.0.1:<port>` accepts a TCP connection, or
+     * false after `timeoutMs`. Used to detect the Vite dev server is up.
+     */
+    waitForPort(port, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        return new Promise((resolve) => {
+            const attempt = () => {
+                const socket = net.connect({ port, host: "127.0.0.1" });
+                let settled = false;
+                const done = (ok) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    socket.destroy();
+                    if (ok) {
+                        resolve(true);
+                    }
+                    else if (Date.now() >= deadline) {
+                        resolve(false);
+                    }
+                    else {
+                        setTimeout(attempt, 250);
+                    }
+                };
+                socket.once("connect", () => done(true));
+                socket.once("error", () => done(false));
+                socket.setTimeout(1000, () => done(false));
+            };
+            attempt();
+        });
+    }
     buildEnvData(platform, projectData, prepareData) {
         var _a, _b, _c;
         const { env } = prepareData;
@@ -477,6 +625,13 @@ class BundlerCompilerService extends events_1.EventEmitter {
             bundlerProcess.kill("SIGINT");
             delete this.bundlerProcesses[platform];
         }
+        // Tear down the Vite dev server we manage alongside the build watcher.
+        const viteServeProcess = this.viteServeProcesses[platform];
+        if (viteServeProcess) {
+            await this.$cleanupService.removeKillProcess(viteServeProcess.pid.toString());
+            viteServeProcess.kill("SIGINT");
+            delete this.viteServeProcesses[platform];
+        }
     }
     handleHMRMessage(message, platformData, projectData, prepareData) {
         // handle new bundler hmr packets

package/lib/services/ios-project-service.js

@@ -265,8 +265,7 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         return Promise.resolve();
     }
     async isDynamicFramework(frameworkPath) {
-        const isDynamicFrameworkBundle = async (bundlePath, frameworkName) => {
-            const frameworkBinaryPath = path.join(bundlePath, frameworkName);
+        const isDynamicFrameworkBundle = async (frameworkBinaryPath) => {
             const fileResult = (await this.$childProcess.spawnFromEvent("file", [frameworkBinaryPath], "close")).stdout;
             const isDynamicallyLinked = _.includes(fileResult, "dynamically linked");
             return isDynamicallyLinked;
@@ -278,7 +277,11 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
                 const singlePlatformFramework = path.join(frameworkPath, library.LibraryIdentifier, library.LibraryPath);
                 if (this.$fs.exists(singlePlatformFramework)) {
                     const frameworkName = path.basename(singlePlatformFramework, path.extname(singlePlatformFramework));
-                    isDynamic = await isDynamicFrameworkBundle(singlePlatformFramework, frameworkName);
+                    let frameworkBinaryPath = path.join(singlePlatformFramework, frameworkName);
+                    if (library.BinaryPath) {
+                        frameworkBinaryPath = path.join(frameworkPath, library.LibraryIdentifier, library.BinaryPath);
+                    }
+                    isDynamic = await isDynamicFrameworkBundle(frameworkBinaryPath);
                     break;
                 }
             }
@@ -286,7 +289,7 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         }
         else {
             const frameworkName = path.basename(frameworkPath, path.extname(frameworkPath));
-            return await isDynamicFrameworkBundle(frameworkPath, frameworkName);
+            return await isDynamicFrameworkBundle(path.join(frameworkPath, frameworkName));
         }
     }
     /**
@@ -623,6 +626,27 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         await this.prepareFrameworks(pluginPlatformsFolderPath, pluginData, projectData);
         await this.prepareStaticLibs(pluginPlatformsFolderPath, pluginData, projectData);
     }
+    shouldRepreparePlugin(pluginData, projectData) {
+        const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(IOSProjectService.IOS_PLATFORM_NAME);
+        for (const fileName of this.getAllLibsForPluginWithFileExtension(pluginData, ".a")) {
+            const staticLibPath = path.join(pluginPlatformsFolderPath, fileName);
+            const libraryName = path.basename(staticLibPath, ".a");
+            const headersSubpath = path.join(path.dirname(staticLibPath), "include", libraryName);
+            if (!this.$fs.exists(headersSubpath)) {
+                continue;
+            }
+            const headerFiles = this.$fs
+                .readDirectory(headersSubpath)
+                .filter((f) => path.extname(f) === ".h" &&
+                this.$fs.getFsStats(path.join(headersSubpath, f)).isFile());
+            if (headerFiles.length > 0 &&
+                !this.$fs.exists(path.join(headersSubpath, "module.modulemap"))) {
+                this.$logger.trace(`Plugin ${pluginData.name}: modulemap missing at ${headersSubpath}, will re-prepare`);
+                return true;
+            }
+        }
+        return false;
+    }
     async removePluginNativeCode(pluginData, projectData) {
         const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(IOSProjectService.IOS_PLATFORM_NAME);
         this.removeNativeSourceCode(pluginPlatformsFolderPath, pluginData, projectData);

package/lib/services/plugins-service.js

@@ -107,6 +107,7 @@ class PluginsService {
         }
     }
     async preparePluginNativeCode({ pluginData, platform, projectData, }) {
+        var _a, _b, _c;
         const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
         const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(platform);
         if (this.$fs.exists(pluginPlatformsFolderPath)) {
@@ -114,8 +115,10 @@ class PluginsService {
             const allPluginsNativeHashes = this.getAllPluginsNativeHashes(pathToPluginsBuildFile);
             const oldPluginNativeHashes = allPluginsNativeHashes[pluginData.name];
             const currentPluginNativeHashes = await this.getPluginNativeHashes(pluginPlatformsFolderPath);
-            if (!oldPluginNativeHashes ||
-                this.$filesHashService.hasChangesInShasums(oldPluginNativeHashes, currentPluginNativeHashes)) {
+            const needsReprepare = !oldPluginNativeHashes ||
+                this.$filesHashService.hasChangesInShasums(oldPluginNativeHashes, currentPluginNativeHashes) ||
+                ((_c = (_b = (_a = platformData.platformProjectService).shouldRepreparePlugin) === null || _b === void 0 ? void 0 : _b.call(_a, pluginData, projectData)) !== null && _c !== void 0 ? _c : false);
+            if (needsReprepare) {
                 await platformData.platformProjectService.preparePluginNativeCode(pluginData, projectData);
                 const updatedPluginNativeHashes = await this.getPluginNativeHashes(pluginPlatformsFolderPath);
                 this.setPluginNativeHashes({
@@ -366,7 +369,12 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
     getNodeModuleData(module, projectDir) {
         // module can be  modulePath or moduleName
         if (!this.$fs.exists(module) || path.basename(module) !== "package.json") {
-            module = this.getPackageJsonFilePathForModule(module, projectDir);
+            const resolvedPath = this.getPackageJsonFilePathForModule(module, projectDir);
+            if (!resolvedPath) {
+                this.$logger.warn(`Could not find module ${color_1.color.yellow(module)}. It may have been removed or is not installed. Skipping.`);
+                return null;
+            }
+            module = resolvedPath;
         }
         const data = this.$fs.readJson(module);
         return {
@@ -384,7 +392,7 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
     async getAllInstalledModules(projectData) {
         await this.ensure(projectData);
         const nodeModules = this.getDependencies(projectData.projectDir);
-        return _.map(nodeModules, (nodeModuleName) => this.getNodeModuleData(nodeModuleName, projectData.projectDir));
+        return _.map(nodeModules, (nodeModuleName) => this.getNodeModuleData(nodeModuleName, projectData.projectDir)).filter(Boolean);
     }
     async executeNpmCommand(npmCommandName, npmCommandArguments, projectData) {
         if (npmCommandName === PluginsService.INSTALL_COMMAND_NAME) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nativescript",
   "main": "./lib/nativescript-cli-lib.js",
-  "version": "9.1.0-alpha.2",
+  "version": "9.1.0-alpha.4",
   "author": "NativeScript <oss@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {