@expo-harmony/cli 55.0.26-harmony.8 → 55.0.26-harmony.9

package/src/run/run.ts

@@ -7,33 +7,18 @@ import {
   selectDeviceAsync,
 } from './devices';
 import { HarmonyCliError } from '../errors';
-import { exportEmbedAsync } from '../exportEmbed/export';
-import type { HarmonyExportManifest } from '../exportEmbed/manifest';
-import {
-  resolveHarmonyBuildPlanAsync,
-  resolveHarmonyEmulator,
-  resolveHarmonyToolchain,
-  type HarmonyBuildPlan,
-} from '../tools';
-import { installHarmonyDependenciesAsync } from './install';
+import { resolveHarmonyEmulator, resolveHarmonyToolchain } from '../native/toolchain';
+import { type HarmonyBuildPlan } from '../native/types';
 import {
   requireExistingMetroAsync,
   startExpoMetroAsync,
   type MetroSession,
 } from './metro';
-import {
-  commitHarmonyNativeBuildCacheAsync,
-  prepareHarmonyNativeBuildCacheAsync,
-} from './cache';
-import { toPosixPath } from '../path';
 import { withHarmonyProjectLockAsync } from '../projectLock';
-import {
-  ensureGeneratedProjectAsync,
-  isNonEmptyRegularFile,
-  progress,
-  runCheckedAsync,
-  timed,
-} from '../buildHap/common';
+import { buildNativeAsync, type NativeBuildResult } from '../native/build';
+import { prepareNativeProjectAsync } from '../native/prepareProject';
+import { progress } from '../log';
+import { timedAsync } from '../profile';
 
 export interface HarmonyRunOptions {
   appId?: string;
@@ -47,11 +32,9 @@ export interface HarmonyRunOptions {
   variant?: 'debug' | 'release';
 }
 
-export interface HarmonyRunResult {
+export interface HarmonyRunResult extends NativeBuildResult {
   bundleName: string;
   device: { id: string; transport: string };
-  export: null | { assetCount: number; bundleSha256: string; sourceMapSha256: string };
-  hapPath: string;
   installed: boolean;
   launched: true;
   metro: { owner: 'disabled' | 'existing' | 'started'; port: number };
@@ -62,7 +45,6 @@ export interface HarmonyRunResult {
 }
 
 interface HarmonyRunSessionOptions extends HarmonyRunOptions {
-  /** Give a CLI-started Metro process ownership of the current terminal. */
   interactiveBundler?: boolean;
 }
 
@@ -101,10 +83,10 @@ function resolveRunIdentity(plan: HarmonyBuildPlan, options: NormalizedRunOption
 }
 
 async function runHarmonyUnlockedAsync(
-  projectRoot: string,
+  root: string,
   options: HarmonyRunSessionOptions = {}
 ): Promise<HarmonyRunSession> {
-  const normalizedOptions: NormalizedRunOptions = {
+  const settings: NormalizedRunOptions = {
     appId: options.appId,
     device: options.device,
     interactiveBundler: Boolean(options.interactiveBundler),
@@ -118,105 +100,52 @@ async function runHarmonyUnlockedAsync(
   };
   const steps: Record<string, number> = {};
 
-  await ensureGeneratedProjectAsync(projectRoot, {
-    ...normalizedOptions,
-    skipGeneratedProjectCheck: true,
+  const plan = await prepareNativeProjectAsync(root, {
+    ...settings,
+    check: false,
   }, steps);
 
-  const plan = await timed(steps, 'buildPlan', () => resolveHarmonyBuildPlanAsync(
-    projectRoot,
-    { buildMode: normalizedOptions.variant }
-  ));
-  const identity = resolveRunIdentity(plan, normalizedOptions);
-  const toolchain = resolveHarmonyToolchain();
+  const identity = resolveRunIdentity(plan, settings);
+  const tools = resolveHarmonyToolchain();
 
-  progress(normalizedOptions, 'Selecting a Harmony device or emulator');
-  const device = await timed(steps, 'device', () => selectDeviceAsync(
-    toolchain.hdc,
-    normalizedOptions.device,
+  progress(settings, 'Selecting a Harmony device or emulator');
+  const device = await timedAsync(steps, 'device', () => selectDeviceAsync(
+    tools.hdc,
+    settings.device,
     {
       cwd: plan.harmonyRoot,
-      emulator: resolveHarmonyEmulator(toolchain),
-      emulatorLogFile: path.join(projectRoot, '.expo', 'harmony', 'emulator.log'),
-      onProgress: message => progress(normalizedOptions, message),
+      emulator: resolveHarmonyEmulator(tools),
+      emulatorLogFile: path.join(root, '.expo', 'harmony', 'emulator.log'),
+      onProgress: message => progress(settings, message),
     }
   ));
 
-  let exportManifest: HarmonyExportManifest | null = null;
-  if (normalizedOptions.variant === 'release') {
-    progress(normalizedOptions, 'Exporting the release Hermes bundle');
-    exportManifest = await timed(steps, 'export', () => exportEmbedAsync(
-      projectRoot,
-      { resetCache: normalizedOptions.resetCache, skipDoctor: true }
-    ));
-  } else {
-    steps.export = 0;
-  }
-
-  progress(normalizedOptions, 'Installing Harmony project dependencies');
-  await timed(steps, 'ohpm', () => installHarmonyDependenciesAsync(plan, toolchain));
+  const built = await buildNativeAsync(root, plan, tools, settings, steps);
 
   let metro: HarmonyRunSession['metro'] = {
     owner: 'disabled',
-    port: normalizedOptions.port,
+    port: settings.port,
     stop: async () => {},
     waitAsync: async () => {},
   };
-  try {
-    progress(normalizedOptions, 'Checking Harmony native dependency cache');
-    const nativeBuildCache = await timed(steps, 'nativeCache', () => (
-      prepareHarmonyNativeBuildCacheAsync(projectRoot, plan)
-    ));
 
-    if (nativeBuildCache.changed) {
-      progress(normalizedOptions, 'Invalidated stale Harmony native build objects');
-    }
-
-    progress(normalizedOptions, `Building the ${normalizedOptions.variant} HAP`);
-    const buildEnv = {
-      ...process.env,
-      EXPO_HARMONY_NODE: process.env.EXPO_HARMONY_NODE || process.execPath,
-      EXPO_METRO_TARGET: 'harmony',
-      HERMES_V1_ENABLED: 'true',
-      ...(normalizedOptions.variant === 'release' ? { EXPO_HARMONY_BUNDLE_PREBUILT: '1' } : {}),
-      ...(toolchain.sdkHome && !process.env.DEVECO_SDK_HOME
-        ? { DEVECO_SDK_HOME: toolchain.sdkHome }
-        : {}),
-    };
-    await timed(steps, 'build', () => runCheckedAsync(toolchain.hvigor.command, [
-      ...toolchain.hvigor.args,
-      ...plan.hvigorArgs,
-    ], {
-      code: 'ERR_HARMONY_BUILD_FAILED',
-      cwd: plan.harmonyRoot,
-      env: buildEnv,
-      message: 'Hvigor build',
-      operation: 'hvigor-build',
-      timeoutMs: 15 * 60_000,
-    }));
-
-    if (!isNonEmptyRegularFile(plan.expectedHap)) {
-      throw new HarmonyCliError('ERR_HARMONY_HAP_MISSING', 'Hvigor completed without producing the expected non-empty regular HAP.', { operation: 'verify-hap' });
-    }
-
-    await timed(steps, 'nativeCacheCommit', () => commitHarmonyNativeBuildCacheAsync(nativeBuildCache));
-
-    if (normalizedOptions.variant === 'debug') {
-      progress(normalizedOptions, normalizedOptions.noBundler
+  try {
+    if (settings.variant === 'debug') {
+      progress(settings, settings.noBundler
         ? 'Connecting to the existing Expo Metro server'
         : 'Starting Expo Metro');
-      metro = await timed(steps, 'metro', () => normalizedOptions.noBundler
-        ? requireExistingMetroAsync(normalizedOptions.port)
-        : startExpoMetroAsync(projectRoot, {
-            interactive: normalizedOptions.interactiveBundler,
-            port: normalizedOptions.port,
-            resetCache: normalizedOptions.resetCache,
+      metro = await timedAsync(steps, 'metro', () => settings.noBundler
+        ? requireExistingMetroAsync(settings.port)
+        : startExpoMetroAsync(root, {
+            interactive: settings.interactiveBundler,
+            port: settings.port,
+            resetCache: settings.resetCache,
           }));
 
-      await timed(steps, 'metroPort', () => configureMetroPortAsync(
-        toolchain.hdc,
+      await timedAsync(steps, 'metroPort', () => configureMetroPortAsync(
+        tools.hdc,
         device,
-        normalizedOptions.port,
+        settings.port,
         { cwd: plan.harmonyRoot }
       ));
     } else {
@@ -224,21 +153,21 @@ async function runHarmonyUnlockedAsync(
       steps.metroPort = 0;
     }
 
-    if (normalizedOptions.noInstall) {
+    if (settings.noInstall) {
       steps.install = 0;
     } else {
-      progress(normalizedOptions, `Installing the HAP on ${device.id}`);
-      await timed(steps, 'install', () => installHapAsync(
-        toolchain.hdc,
+      progress(settings, `Installing the HAP on ${device.id}`);
+      await timedAsync(steps, 'install', () => installHapAsync(
+        tools.hdc,
         device,
         plan.expectedHap,
         { cwd: plan.harmonyRoot }
       ));
     }
 
-    progress(normalizedOptions, `Launching ${identity.bundleName}`);
-    await timed(steps, 'launch', () => launchAppAsync(
-      toolchain.hdc,
+    progress(settings, `Launching ${identity.bundleName}`);
+    await timedAsync(steps, 'launch', () => launchAppAsync(
+      tools.hdc,
       device,
       identity.bundleName,
       identity.abilityName,
@@ -251,15 +180,8 @@ async function runHarmonyUnlockedAsync(
         id: device.id,
         transport: device.transport,
       },
-      export: exportManifest
-        ? {
-            assetCount: exportManifest.assets.length,
-            bundleSha256: exportManifest.bundle.sha256,
-            sourceMapSha256: exportManifest.sourceMap.sha256,
-          }
-        : null,
-      hapPath: toPosixPath(path.relative(projectRoot, plan.expectedHap)),
-      installed: !normalizedOptions.noInstall,
+      ...built,
+      installed: !settings.noInstall,
       launched: true,
       metro: {
         owner: metro.owner,
@@ -268,32 +190,37 @@ async function runHarmonyUnlockedAsync(
       ok: true,
       schemaVersion: 1,
       steps,
-      variant: normalizedOptions.variant,
+      variant: settings.variant,
     };
 
     return { metro, result };
   } catch (error) {
     await metro.stop();
-    throw error;
+
+    throw new HarmonyCliError(error?.code || 'ERR_HARMONY_UNKNOWN', error?.message || 'Harmony run failed.', {
+      cause: error,
+      exitCode: error?.exitCode,
+      operation: error?.operation,
+    });
   }
 }
 
 async function runHarmonySessionAsync(
-  projectRoot: string,
+  root: string,
   options: HarmonyRunSessionOptions = {}
 ): Promise<HarmonyRunSession> {
   return withHarmonyProjectLockAsync(
-    projectRoot,
+    root,
     'run',
-    () => runHarmonyUnlockedAsync(projectRoot, options)
+    () => runHarmonyUnlockedAsync(root, options)
   );
 }
 
 async function runHarmonyAsync(
-  projectRoot: string,
+  root: string,
   options: HarmonyRunOptions = {}
 ): Promise<HarmonyRunResult> {
-  const session = await runHarmonySessionAsync(projectRoot, options);
+  const session = await runHarmonySessionAsync(root, options);
 
   try {
     return session.result;

package/src/start/index.ts

@@ -0,0 +1,31 @@
+import { parseCommandArgs, type Command } from '../command';
+import { parseStartArgs } from './options';
+
+export const command: Command = async (argv, io) => {
+  const args = parseCommandArgs(parseStartArgs, argv, io);
+  if (!args) return 0;
+
+  const { projectRoot: root, options } = args;
+  const { startExpoMetroAsync } = await import('../run/metro.js');
+
+  const metro = await startExpoMetroAsync(root, {
+    ...options,
+    interactive: true,
+  });
+
+  try {
+    if (metro.owner === 'existing') {
+      io.log(`Expo Metro is already running on port ${metro.port}.`);
+      if (options.resetCache) {
+        io.warn('Stop the existing Metro server and run this command again to reset its cache.');
+      }
+    } else {
+      io.log('\n› Logs for your project will appear below. Press Ctrl+C to exit.');
+      await metro.waitAsync();
+    }
+
+    return 0;
+  } finally {
+    await metro.stop();
+  }
+};

package/build/buildHap/common.d.ts

@@ -1,24 +0,0 @@
-interface HarmonyBuildPipelineOptions {
-    io?: Pick<Console, 'error' | 'log' | 'warn'>;
-    requireDeviceTools?: boolean;
-    /** @internal Reuse the native project without an isolated drift check. */
-    skipGeneratedProjectCheck?: boolean;
-    sync: boolean;
-    variant: 'debug' | 'release';
-}
-interface CheckedProcessOptions {
-    code: string;
-    cwd: string;
-    env?: NodeJS.ProcessEnv;
-    message: string;
-    operation: string;
-    outputLimit?: number;
-    timeoutMs?: number;
-}
-declare function progress(options: HarmonyBuildPipelineOptions, message: string): void;
-declare function timed<T>(steps: Record<string, number>, name: string, operation: () => Promise<T> | T): Promise<T>;
-declare function isNonEmptyRegularFile(file: string): boolean;
-declare function runCheckedAsync(command: string, args: string[], options: CheckedProcessOptions): Promise<import("../process").ProcessResult>;
-declare function ensureGeneratedProjectAsync(projectRoot: string, options: HarmonyBuildPipelineOptions, steps: Record<string, number>): Promise<void>;
-export { ensureGeneratedProjectAsync, isNonEmptyRegularFile, progress, runCheckedAsync, timed, };
-export type { CheckedProcessOptions, HarmonyBuildPipelineOptions };

package/build/buildHap/common.js

@@ -1,92 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureGeneratedProjectAsync = ensureGeneratedProjectAsync;
-exports.isNonEmptyRegularFile = isNonEmptyRegularFile;
-exports.progress = progress;
-exports.runCheckedAsync = runCheckedAsync;
-exports.timed = timed;
-const node_fs_1 = __importDefault(require("node:fs"));
-const doctor_1 = require("../doctor/doctor");
-const errors_1 = require("../errors");
-const check_1 = require("../prebuild/check");
-const prebuild_1 = require("../prebuild/prebuild");
-const process_1 = require("../process");
-const tools_1 = require("../tools");
-function progress(options, message) {
-    options.io?.log?.(`› ${message}`);
-}
-async function timed(steps, name, operation) {
-    const started = performance.now();
-    try {
-        return await operation();
-    }
-    finally {
-        steps[name] = Math.max(0, Math.round(performance.now() - started));
-    }
-}
-function assertDoctor(result) {
-    if (result.ok)
-        return;
-    const failing = result.checks.filter(check => check.status === 'error').map(check => check.id);
-    throw new errors_1.HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', `Harmony doctor found blocking checks: ${failing.join(', ') || 'unknown'}.`, { operation: 'doctor' });
-}
-function isNonEmptyRegularFile(file) {
-    try {
-        const stat = node_fs_1.default.lstatSync(file);
-        return !stat.isSymbolicLink() && stat.isFile() && stat.size > 0;
-    }
-    catch {
-        return false;
-    }
-}
-async function runCheckedAsync(command, args, options) {
-    const result = await (0, process_1.spawnAsync)(command, args, {
-        capture: true,
-        cwd: options.cwd,
-        env: options.env,
-        operation: options.operation,
-        outputLimit: options.outputLimit || 2 * 1024 * 1024,
-        timeoutMs: options.timeoutMs,
-    });
-    if (result.code !== 0 || result.timedOut) {
-        const diagnostics = (0, process_1.formatDiagnostics)(result);
-        throw new errors_1.HarmonyCliError(options.code, `${options.message} exited with code ${result.code}${result.timedOut ? ' after timing out' : ''}.${diagnostics ? `\n${diagnostics}` : ''}`, { exitCode: result.code || 1, operation: options.operation });
-    }
-    return result;
-}
-async function ensureGeneratedProjectAsync(projectRoot, options, steps) {
-    const plan = await (0, tools_1.resolveHarmonyBuildPlanIfPresentAsync)(projectRoot, {
-        buildMode: options.variant,
-    });
-    const exists = Boolean(plan && node_fs_1.default.existsSync(plan.harmonyRoot));
-    progress(options, 'Checking the Harmony project');
-    const doctor = await timed(steps, 'doctor', () => (0, doctor_1.doctorAsync)(projectRoot, {
-        requireBuildTools: true,
-        requireDeviceTools: options.requireDeviceTools,
-        validateGeneratedProject: exists,
-        validateModules: false,
-    }));
-    assertDoctor(doctor);
-    if (!exists || options.sync) {
-        progress(options, exists
-            ? 'Synchronizing the generated Harmony project'
-            : 'Generating the missing Harmony project');
-        await timed(steps, 'prebuild', () => (0, prebuild_1.prebuildParsedAsync)(projectRoot, [], { buildType: options.variant }));
-        steps.cngCheck = 0;
-        return;
-    }
-    steps.prebuild = 0;
-    if (options.skipGeneratedProjectCheck) {
-        steps.cngCheck = 0;
-        return;
-    }
-    progress(options, 'Checking CNG ownership and drift');
-    const check = await timed(steps, 'cngCheck', () => (0, check_1.checkAsync)(projectRoot, { buildType: options.variant }));
-    if (!check.clean) {
-        const summary = check.changes.slice(0, 8).map(change => `${change.type}:${change.path}`).join(', ');
-        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_DRIFT', `Generated Harmony files differ from CNG desired state${summary ? ` (${summary})` : ''}. Run expo-harmony prebuild or retry with --sync.`, { operation: 'check' });
-    }
-}

package/build/run/install.d.ts

@@ -1,7 +0,0 @@
-import type { HarmonyBuildPlan, HarmonyToolchain } from '../tools';
-interface InstallOptions {
-    timeoutMs?: number;
-}
-/** Runs OHPM against the generated project without rewriting its manifest. */
-declare function installHarmonyDependenciesAsync(plan: HarmonyBuildPlan, toolchain: HarmonyToolchain, options?: InstallOptions): Promise<void>;
-export { installHarmonyDependenciesAsync };

package/build/run/install.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.installHarmonyDependenciesAsync = installHarmonyDependenciesAsync;
-const errors_1 = require("../errors");
-const process_1 = require("../process");
-function installMessage(result) {
-    const diagnostics = (0, process_1.formatDiagnostics)(result);
-    return `OHPM install exited with code ${result.code}${result.timedOut ? ' after timing out' : ''}.`
-        + `${diagnostics ? `\n${diagnostics}` : ''}`;
-}
-/** Runs OHPM against the generated project without rewriting its manifest. */
-async function installHarmonyDependenciesAsync(plan, toolchain, options = {}) {
-    const result = await (0, process_1.spawnAsync)(toolchain.ohpm.command, [...toolchain.ohpm.args, 'install', '--all'], {
-        capture: true,
-        cwd: plan.harmonyRoot,
-        operation: 'ohpm-install',
-        outputLimit: 2 * 1024 * 1024,
-        timeoutMs: options.timeoutMs || 5 * 60_000,
-    });
-    if (result.code !== 0 || result.timedOut) {
-        throw new errors_1.HarmonyCliError('ERR_HARMONY_OHPM_FAILED', installMessage(result), {
-            exitCode: result.code || 1,
-            operation: 'ohpm-install',
-        });
-    }
-}

package/build/tools.d.ts

@@ -1,39 +0,0 @@
-import { type HarmonyBuildDescriptor } from '@expo-harmony/prebuild-config/build-descriptor';
-export interface HarmonyTool {
-    args: string[];
-    command: string;
-    source: 'deveco' | 'override' | 'path';
-}
-export interface HarmonyToolchain {
-    hdc: HarmonyTool;
-    hvigor: HarmonyTool;
-    ohpm: HarmonyTool;
-    sdkHome: string | null;
-    toolsRoot: string | null;
-}
-export interface HarmonyBuildPlan {
-    abilityName: string;
-    buildMode: 'debug' | 'release';
-    bundleName: string;
-    expectedHap: string;
-    exportPaths: HarmonyBuildDescriptor['export'];
-    harmonyRoot: string;
-    hvigorArgs: string[];
-    moduleName: string;
-    moduleRoot: string;
-    nativeCache: HarmonyBuildDescriptor['nativeCache'];
-    nativeInputs: HarmonyBuildDescriptor['nativeInputs'];
-    projectFiles: HarmonyBuildDescriptor['projectFiles'];
-    productName: string;
-    targetName: string;
-}
-declare function resolveHarmonyToolchain(): HarmonyToolchain;
-declare function createHarmonyToolchainEnv(toolchain?: HarmonyToolchain): NodeJS.ProcessEnv;
-declare function resolveHarmonyEmulator(toolchain: HarmonyToolchain): HarmonyTool;
-declare function resolveHarmonyBuildPlanIfPresentAsync(projectRoot: string, options?: {
-    buildMode?: 'debug' | 'release';
-}): Promise<HarmonyBuildPlan | null>;
-declare function resolveHarmonyBuildPlanAsync(projectRoot: string, options?: {
-    buildMode?: 'debug' | 'release';
-}): Promise<HarmonyBuildPlan>;
-export { createHarmonyToolchainEnv, resolveHarmonyBuildPlanAsync, resolveHarmonyBuildPlanIfPresentAsync, resolveHarmonyEmulator, resolveHarmonyToolchain, };

package/src/buildHap/common.ts

@@ -1,145 +0,0 @@
-import fs from 'node:fs';
-
-import { doctorAsync, type DoctorResult } from '../doctor/doctor';
-import { HarmonyCliError } from '../errors';
-import { checkAsync } from '../prebuild/check';
-import { prebuildParsedAsync } from '../prebuild/prebuild';
-import { formatDiagnostics, spawnAsync } from '../process';
-import { resolveHarmonyBuildPlanIfPresentAsync } from '../tools';
-
-interface HarmonyBuildPipelineOptions {
-  io?: Pick<Console, 'error' | 'log' | 'warn'>;
-  requireDeviceTools?: boolean;
-  /** @internal Reuse the native project without an isolated drift check. */
-  skipGeneratedProjectCheck?: boolean;
-  sync: boolean;
-  variant: 'debug' | 'release';
-}
-
-interface CheckedProcessOptions {
-  code: string;
-  cwd: string;
-  env?: NodeJS.ProcessEnv;
-  message: string;
-  operation: string;
-  outputLimit?: number;
-  timeoutMs?: number;
-}
-
-function progress(options: HarmonyBuildPipelineOptions, message: string): void {
-  options.io?.log?.(`› ${message}`);
-}
-
-async function timed<T>(
-  steps: Record<string, number>,
-  name: string,
-  operation: () => Promise<T> | T
-): Promise<T> {
-  const started = performance.now();
-  try {
-    return await operation();
-  } finally {
-    steps[name] = Math.max(0, Math.round(performance.now() - started));
-  }
-}
-
-function assertDoctor(result: DoctorResult): void {
-  if (result.ok) return;
-
-  const failing = result.checks.filter(check => check.status === 'error').map(check => check.id);
-
-  throw new HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', `Harmony doctor found blocking checks: ${failing.join(', ') || 'unknown'}.`, { operation: 'doctor' });
-}
-
-function isNonEmptyRegularFile(file: string): boolean {
-  try {
-    const stat = fs.lstatSync(file);
-    return !stat.isSymbolicLink() && stat.isFile() && stat.size > 0;
-  } catch {
-    return false;
-  }
-}
-
-async function runCheckedAsync(
-  command: string,
-  args: string[],
-  options: CheckedProcessOptions
-) {
-  const result = await spawnAsync(command, args, {
-    capture: true,
-    cwd: options.cwd,
-    env: options.env,
-    operation: options.operation,
-    outputLimit: options.outputLimit || 2 * 1024 * 1024,
-    timeoutMs: options.timeoutMs,
-  });
-
-  if (result.code !== 0 || result.timedOut) {
-    const diagnostics = formatDiagnostics(result);
-    throw new HarmonyCliError(
-      options.code,
-      `${options.message} exited with code ${result.code}${result.timedOut ? ' after timing out' : ''}.${diagnostics ? `\n${diagnostics}` : ''}`,
-      { exitCode: result.code || 1, operation: options.operation }
-    );
-  }
-
-  return result;
-}
-
-async function ensureGeneratedProjectAsync(
-  projectRoot: string,
-  options: HarmonyBuildPipelineOptions,
-  steps: Record<string, number>
-) {
-  const plan = await resolveHarmonyBuildPlanIfPresentAsync(projectRoot, {
-    buildMode: options.variant,
-  });
-  const exists = Boolean(plan && fs.existsSync(plan.harmonyRoot));
-
-  progress(options, 'Checking the Harmony project');
-  const doctor = await timed(steps, 'doctor', () => doctorAsync(projectRoot, {
-    requireBuildTools: true,
-    requireDeviceTools: options.requireDeviceTools,
-    validateGeneratedProject: exists,
-    validateModules: false,
-  }));
-  assertDoctor(doctor);
-
-  if (!exists || options.sync) {
-    progress(options, exists
-      ? 'Synchronizing the generated Harmony project'
-      : 'Generating the missing Harmony project');
-    await timed(steps, 'prebuild', () => prebuildParsedAsync(
-      projectRoot,
-      [],
-      { buildType: options.variant }
-    ));
-    steps.cngCheck = 0;
-    return;
-  }
-
-  steps.prebuild = 0;
-  if (options.skipGeneratedProjectCheck) {
-    steps.cngCheck = 0;
-    return;
-  }
-  progress(options, 'Checking CNG ownership and drift');
-  const check = await timed(steps, 'cngCheck', () => checkAsync(projectRoot, { buildType: options.variant }));
-  if (!check.clean) {
-    const summary = check.changes.slice(0, 8).map(change => `${change.type}:${change.path}`).join(', ');
-    throw new HarmonyCliError(
-      'ERR_HARMONY_MANIFEST_DRIFT',
-      `Generated Harmony files differ from CNG desired state${summary ? ` (${summary})` : ''}. Run expo-harmony prebuild or retry with --sync.`,
-      { operation: 'check' }
-    );
-  }
-}
-
-export {
-  ensureGeneratedProjectAsync,
-  isNonEmptyRegularFile,
-  progress,
-  runCheckedAsync,
-  timed,
-};
-export type { CheckedProcessOptions, HarmonyBuildPipelineOptions };