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

package/src/{run → native}/cache.ts

@@ -4,10 +4,10 @@ import path from 'node:path';
 import {
   HarmonyNativeInputsFingerprintVersion,
   fingerprintHarmonyNativeInputsSync,
-} from '@expo-harmony/config-plugins/native-inputs';
+} from '@expo-harmony/config-plugins/internal/native-inputs';
 
 import { HarmonyCliError } from '../errors';
-import type { HarmonyBuildPlan } from '../tools';
+import { type HarmonyBuildPlan } from './types';
 
 export interface HarmonyNativeBuildCacheState {
   artifactCount: number;
@@ -17,13 +17,14 @@ export interface HarmonyNativeBuildCacheState {
   fingerprintVersion: number;
 }
 
-const CacheSchemaVersion = 1;
+const SchemaVersion = 1;
 
 async function readOptionalFile(file) {
   try {
     return await fs.promises.readFile(file);
   } catch (error) {
     if (error?.code === 'ENOENT') return null;
+
     throw new HarmonyCliError(
       error.code || 'ERR_HARMONY_NATIVE_CACHE',
       error.message || `Cannot read a Harmony native cache input: ${file}`,
@@ -33,14 +34,14 @@ async function readOptionalFile(file) {
 }
 
 async function resolveNativeDependencyFingerprintAsync(
-  projectRoot: string,
+  root: string,
   plan: HarmonyBuildPlan
 ) {
   try {
     return fingerprintHarmonyNativeInputsSync({
       lockfile: plan.nativeInputs.lockfile,
       manifest: plan.nativeInputs.manifest,
-      projectRoot,
+      projectRoot: root,
     });
   } catch (cause) {
     throw new HarmonyCliError(
@@ -52,10 +53,10 @@ async function resolveNativeDependencyFingerprintAsync(
 }
 
 async function prepareHarmonyNativeBuildCacheAsync(
-  projectRoot: string,
+  root: string,
   plan: HarmonyBuildPlan
 ): Promise<HarmonyNativeBuildCacheState> {
-  const current = await resolveNativeDependencyFingerprintAsync(projectRoot, plan);
+  const current = await resolveNativeDependencyFingerprintAsync(root, plan);
   const file = plan.nativeCache.stateFile;
   const source = await readOptionalFile(file);
   let saved = null;
@@ -68,7 +69,7 @@ async function prepareHarmonyNativeBuildCacheAsync(
     }
   }
 
-  const changed = saved?.schemaVersion !== CacheSchemaVersion
+  const changed = saved?.schemaVersion !== SchemaVersion
     || saved?.fingerprintVersion !== HarmonyNativeInputsFingerprintVersion
     || saved?.fingerprint !== current.fingerprint;
 
@@ -94,7 +95,7 @@ async function commitHarmonyNativeBuildCacheAsync(state: HarmonyNativeBuildCache
     artifactCount: state.artifactCount,
     fingerprint: state.fingerprint,
     fingerprintVersion: state.fingerprintVersion,
-    schemaVersion: CacheSchemaVersion,
+    schemaVersion: SchemaVersion,
   }, null, 2)}\n`);
   await fs.promises.rename(temp, state.cacheFile);
 }

package/src/native/hvigor.ts

@@ -0,0 +1,81 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fingerprintHarmonyNativeInputsSync } from '@expo-harmony/config-plugins/internal/native-inputs';
+
+import { HarmonyCliError } from '../errors';
+import { createHarmonyToolchainEnv, resolveHarmonyToolchain } from './toolchain';
+
+function nodeExecutable(): string {
+  const candidates = process.env.EXPO_HARMONY_NODE
+    ? [process.env.EXPO_HARMONY_NODE]
+    : [
+        process.execPath,
+        ...(process.env.PATH || '').split(path.delimiter).filter(Boolean)
+          .map(directory => path.join(directory, process.platform === 'win32' ? 'node.exe' : 'node')),
+      ];
+
+  for (const candidate of new Set(candidates)) {
+    const result = spawnSync(candidate, ['-p', 'process.versions.node'], { encoding: 'utf8', timeout: 5_000 });
+    if (result.status === 0 && Number.parseInt(result.stdout, 10) >= 20) return candidate;
+  }
+
+  throw new HarmonyCliError('ERR_HARMONY_NODE', 'Harmony native builds require Node.js 20 or newer. Set EXPO_HARMONY_NODE to its executable.', { operation: 'native-build' });
+}
+
+function run(command: string, args: string[], cwd: string): void {
+  const result = spawnSync(command, args, {
+    cwd,
+    env: { ...createHarmonyToolchainEnv(), EXPO_HARMONY: '1', EXPO_METRO_TARGET: 'harmony', HERMES_V1_ENABLED: 'true' },
+    stdio: 'inherit',
+    timeout: 10 * 60_000,
+  });
+
+  if (result.error || result.status !== 0) {
+    throw new HarmonyCliError('ERR_HARMONY_NATIVE_BUILD', `Harmony build command failed: ${command} (${result.error?.message || result.status}).`, { cause: result.error, exitCode: result.status || 1, operation: 'native-build' });
+  }
+}
+
+// Hvigor configuration is synchronous; linking must finish before task execution.
+export function prepareHarmonyNativeBuild(root: string, mode: 'debug' | 'release'): void {
+  const harmony = path.join(root, 'harmony');
+
+  if (process.env.EXPO_HARMONY_NATIVE_PREPARED !== '1') {
+    const require = createRequire(path.join(root, 'package.json'));
+    const manifest = path.resolve(path.dirname(require.resolve('@expo-harmony/expo-modules-autolinking')), '../package.json');
+    const bin = path.resolve(path.dirname(manifest), require(manifest).bin['expo-harmony-autolinking']);
+
+    run(nodeExecutable(), [bin, 'link', '--project-root', root, '--harmony-project-path', harmony, '--build-type', mode], root);
+
+    const { ohpm } = resolveHarmonyToolchain();
+    run(ohpm.command, [...ohpm.args, 'install', '--all'], harmony);
+  }
+
+  const { fingerprint } = fingerprintHarmonyNativeInputsSync({
+    projectRoot: root,
+    manifest: path.join(harmony, 'oh-package.json5'),
+    lockfile: path.join(harmony, 'oh-package-lock.json5'),
+  });
+  const file = path.join(harmony, '.hvigor/expo-harmony/native-inputs.cmake');
+  const content = `# Generated native dependency fingerprint.\nadd_compile_definitions(EXPO_HARMONY_NATIVE_INPUTS_SHA256_${fingerprint}=1)\n`;
+  if (fs.existsSync(file) && fs.readFileSync(file, 'utf8') === content) return;
+
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${crypto.randomUUID()}.tmp`;
+
+  try {
+    fs.writeFileSync(temp, content);
+    fs.renameSync(temp, file);
+  } finally {
+    fs.rmSync(temp, { force: true });
+  }
+}
+
+export function bundleHarmonyNativeBuild(root: string): void {
+  if (process.env.EXPO_HARMONY_BUNDLE_PREBUILT === '1') return;
+
+  const require = createRequire(path.join(root, 'package.json'));
+  run(nodeExecutable(), [require.resolve('@expo-harmony/cli/bin/expo-harmony'), 'export:embed', root], root);
+}

package/src/native/install.ts

@@ -0,0 +1,17 @@
+import type { HarmonyBuildPlan } from './types';
+import type { HarmonyToolchain } from './toolchain';
+import { runCheckedAsync } from '../process';
+
+export async function installHarmonyDependenciesAsync(
+  plan: Pick<HarmonyBuildPlan, 'harmonyRoot'>,
+  tools: HarmonyToolchain,
+  options: { timeoutMs?: number } = {}
+): Promise<void> {
+  await runCheckedAsync(tools.ohpm.command, [...tools.ohpm.args, 'install', '--all'], {
+    code: 'ERR_HARMONY_OHPM_FAILED',
+    cwd: plan.harmonyRoot,
+    message: 'OHPM install',
+    operation: 'ohpm-install',
+    timeoutMs: options.timeoutMs || 5 * 60_000,
+  });
+}

package/src/native/prepareProject.ts

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import { linkModulesAsync } from '@expo-harmony/expo-modules-autolinking';
+
+import { doctorAsync } from '../doctor/doctor';
+import { HarmonyCliError } from '../errors';
+import { progress, type Log } from '../log';
+import { timedAsync } from '../profile';
+import { checkAsync } from '../prebuild/check';
+import { prebuildParsedAsync } from '../prebuild/prebuild';
+import { createHarmonyToolchainEnv } from './toolchain';
+import { resolveHarmonyBuildPlanAsync, resolveHarmonyBuildPlanIfPresentAsync } from './project';
+import type { HarmonyBuildPlan } from './types';
+
+interface PrepareProjectOptions {
+  io?: Log;
+  requireDeviceTools?: boolean;
+  check?: boolean;
+  sync: boolean;
+  variant: 'debug' | 'release';
+}
+
+async function prepareNativeProjectAsync(
+  root: string,
+  options: PrepareProjectOptions,
+  steps: Record<string, number>
+): Promise<HarmonyBuildPlan> {
+  const plan = await timedAsync(steps, 'buildPlan', () => resolveHarmonyBuildPlanIfPresentAsync(root, {
+    buildMode: options.variant,
+  }));
+  const exists = Boolean(plan && fs.existsSync(plan.harmonyRoot));
+
+  if (plan?.workflow === 'bare' && options.sync) {
+    throw new HarmonyCliError('ERR_HARMONY_BARE_SYNC', '--sync regenerates CNG projects and cannot be used with a manually maintained bare project.', { operation: 'build' });
+  }
+
+  progress(options, 'Checking the Harmony project');
+  const doctor = await timedAsync(steps, 'doctor', () => doctorAsync(root, {
+    requireBuildTools: true,
+    requireDeviceTools: options.requireDeviceTools,
+    validateGeneratedProject: exists,
+    validateModules: false,
+  }));
+  if (!doctor.ok) {
+    const checks = doctor.checks.filter(check => check.status === 'error').map(check => check.id);
+
+    throw new HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', `Harmony doctor found blocking checks: ${checks.join(', ') || 'unknown'}.`, { operation: 'doctor' });
+  }
+
+  if (plan?.workflow === 'bare') {
+    progress(options, 'Autolinking the bare Harmony project');
+    await timedAsync(steps, 'autolinking', () => linkModulesAsync({
+      projectRoot: root,
+      harmonyProjectPath: plan.harmonyRoot,
+      buildType: options.variant,
+      env: createHarmonyToolchainEnv(),
+    }));
+
+    steps.prebuild = 0;
+    steps.cngCheck = 0;
+
+    return plan;
+  }
+
+  if (!exists || options.sync) {
+    progress(options, exists
+      ? 'Synchronizing the generated Harmony project'
+      : 'Generating the missing Harmony project');
+    await timedAsync(steps, 'prebuild', () => prebuildParsedAsync(
+      root,
+      [],
+      { buildType: options.variant }
+    ));
+    steps.cngCheck = 0;
+
+    return timedAsync(steps, 'buildPlan', () => resolveHarmonyBuildPlanAsync(root, { buildMode: options.variant }));
+  }
+
+  steps.prebuild = 0;
+  if (options.check === false) {
+    steps.cngCheck = 0;
+    return plan;
+  }
+
+  progress(options, 'Checking CNG ownership and drift');
+  const check = await timedAsync(steps, 'cngCheck', () => checkAsync(root, { 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' }
+    );
+  }
+
+  return plan;
+}
+
+export { prepareNativeProjectAsync };

package/src/native/project.ts

@@ -0,0 +1,88 @@
+import { readManifestIfPresentAsync, resolveHarmonyBuildPath, type HarmonyBuildDescriptor } from '@expo-harmony/prebuild-config/internal';
+
+import { HarmonyCliError } from '../errors';
+import { isBareHarmonyProject, resolveBareHarmonyBuildPlan } from './bare';
+import type { CngHarmonyBuildPlan, HarmonyBuildPlan } from './types';
+
+function createHarmonyBuildPlan(
+  root: string,
+  build: HarmonyBuildDescriptor,
+  mode: 'debug' | 'release'
+): CngHarmonyBuildPlan {
+  const resolve = relative => resolveHarmonyBuildPath(root, relative);
+  const variant = build.variants[mode];
+
+  return {
+    workflow: 'cng',
+    abilityName: build.identity.abilityName,
+    buildMode: mode,
+    bundleName: build.identity.bundleName,
+    expectedHap: resolve(variant.expectedHap),
+    exportPaths: Object.fromEntries(
+      Object.entries(build.export).map(([name, relative]) => [name, resolve(relative)])
+    ) as HarmonyBuildPlan['exportPaths'],
+    harmonyRoot: resolve(build.harmonyRoot),
+    hvigorArgs: [...variant.hvigorArgs],
+    moduleName: build.identity.moduleName,
+    moduleRoot: resolve(build.moduleRoot),
+    nativeCache: {
+      invalidationRoots: build.nativeCache.invalidationRoots.map(resolve),
+      stateFile: resolve(build.nativeCache.stateFile),
+    },
+    nativeInputs: {
+      lockfile: resolve(build.nativeInputs.lockfile),
+      manifest: resolve(build.nativeInputs.manifest),
+    },
+    productName: build.identity.productName,
+    projectFiles: Object.fromEntries(
+      Object.entries(build.projectFiles).map(([name, relative]) => [name, resolve(relative)])
+    ) as CngHarmonyBuildPlan['projectFiles'],
+    targetName: build.identity.targetName,
+  };
+}
+
+async function resolveHarmonyBuildPlanIfPresentAsync(
+  root: string,
+  options: { buildMode?: 'debug' | 'release' } = {}
+): Promise<HarmonyBuildPlan | null> {
+  const mode = options.buildMode || 'debug';
+  if (!['debug', 'release'].includes(mode)) {
+    throw new HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Harmony buildMode must be debug or release, received: ${mode}`, { operation: 'resolve-build' });
+  }
+
+  let manifest;
+
+  try {
+    manifest = await readManifestIfPresentAsync(root);
+  } catch (cause) {
+    throw new HarmonyCliError(
+      cause.code || 'ERR_HARMONY_TEMPLATE_INVALID',
+      `Cannot read the generated Harmony build descriptor: ${cause.message}`,
+      { cause, operation: 'resolve-build' }
+    );
+  }
+
+  if (!manifest) {
+    return isBareHarmonyProject(root) ? resolveBareHarmonyBuildPlan(root, mode) : null;
+  }
+
+  return createHarmonyBuildPlan(root, manifest.build, mode);
+}
+
+async function resolveHarmonyBuildPlanAsync(
+  root: string,
+  options: { buildMode?: 'debug' | 'release' } = {}
+): Promise<HarmonyBuildPlan> {
+  const plan = await resolveHarmonyBuildPlanIfPresentAsync(root, options);
+  if (!plan) {
+    throw new HarmonyCliError(
+      'ERR_HARMONY_MANIFEST_DRIFT',
+      'Cannot read the generated Harmony build descriptor because the CNG manifest is missing.',
+      { operation: 'resolve-build' }
+    );
+  }
+
+  return plan;
+}
+
+export { resolveHarmonyBuildPlanAsync, resolveHarmonyBuildPlanIfPresentAsync };

package/src/{tools.ts → native/toolchain.ts}

@@ -2,14 +2,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { resolveHarmonyCommand } from '@expo-harmony/expo-modules-autolinking/tool-command';
 
-import {
-  resolveHarmonyBuildPath,
-  type HarmonyBuildDescriptor,
-} from '@expo-harmony/prebuild-config/build-descriptor';
-import { readManifestIfPresentAsync } from '@expo-harmony/prebuild-config/check';
-
-import { HarmonyCliError } from './errors';
-
 export interface HarmonyTool {
   args: string[];
   command: string;
@@ -24,23 +16,6 @@ export interface HarmonyToolchain {
   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;
-}
-
 function existingFile(candidates: string[]): string | null {
   return candidates.find(candidate => fs.existsSync(candidate)) || null;
 }
@@ -55,7 +30,7 @@ const RequiredSdkComponents = Object.freeze([
   'default/openharmony/toolchains/oh-uni-package.json',
 ]);
 
-function sdkRootsNear(seed) {
+function sdkRootsNear(seed: string): string[] {
   const roots = [];
   let cursor = path.resolve(seed);
 
@@ -75,7 +50,7 @@ function sdkRootsNear(seed) {
   return roots;
 }
 
-function resolveHarmonySdkRoot(env, platform) {
+function resolveHarmonySdkRoot(env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string | null {
   const seeds = [
     env.DEVECO_SDK_HOME,
     env.HARMONY_HOME,
@@ -93,7 +68,7 @@ function resolveHarmonySdkRoot(env, platform) {
   )) || null;
 }
 
-function devEcoInstallRoots(sdkHome) {
+function devEcoInstallRoots(sdkHome: string): string[] {
   const ancestors = [sdkHome, path.dirname(sdkHome), path.dirname(path.dirname(sdkHome))];
   const sdkDirectory = ancestors.find(candidate => path.basename(candidate).toLowerCase() === 'sdk');
   const roots = [
@@ -105,7 +80,7 @@ function devEcoInstallRoots(sdkHome) {
   return [...new Set(roots)];
 }
 
-function devEcoLayouts(sdkHome) {
+function devEcoLayouts(sdkHome: string) {
   return devEcoInstallRoots(sdkHome).flatMap(root => [
     {
       nodeRoot: path.join(root, 'tools', 'node'),
@@ -118,7 +93,11 @@ function devEcoLayouts(sdkHome) {
   ]);
 }
 
-function devEcoNode(layout, platform, env) {
+function devEcoNode(
+  layout: { nodeRoot: string },
+  platform: NodeJS.Platform,
+  env: NodeJS.ProcessEnv
+): Pick<HarmonyTool, 'command' | 'source'> | null {
   if (env.HARMONY_NODE) return { command: env.HARMONY_NODE, source: 'override' };
 
   const executable = platform === 'win32' ? 'node.exe' : 'node';
@@ -134,9 +113,7 @@ function resolveHarmonyToolchain(): HarmonyToolchain {
   const env = process.env;
   const platform = process.platform;
 
-  // Hvigor expects the SDK root containing default/, not default/ itself.
-  // Reject metadata-only candidates so doctor cannot claim an SDK is
-  // buildable without its HMS, OpenHarmony, native, ETS, and toolchain parts.
+  // Hvigor needs the complete SDK root containing default/, not default/ itself.
   const sdkHome = resolveHarmonySdkRoot(env, platform);
   const layouts = sdkHome ? devEcoLayouts(sdkHome) : [];
 
@@ -234,88 +211,4 @@ function resolveHarmonyEmulator(toolchain: HarmonyToolchain): HarmonyTool {
     : { args: [], command: executable, source: 'path' };
 }
 
-function createHarmonyBuildPlan(
-  projectRoot: string,
-  build: HarmonyBuildDescriptor,
-  mode: 'debug' | 'release'
-): HarmonyBuildPlan {
-  const resolve = relative => resolveHarmonyBuildPath(projectRoot, relative);
-  const variant = build.variants[mode];
-
-  return {
-    abilityName: build.identity.abilityName,
-    buildMode: mode,
-    bundleName: build.identity.bundleName,
-    expectedHap: resolve(variant.expectedHap),
-    exportPaths: Object.fromEntries(
-      Object.entries(build.export).map(([name, relative]) => [name, resolve(relative)])
-    ) as HarmonyBuildPlan['exportPaths'],
-    harmonyRoot: resolve(build.harmonyRoot),
-    hvigorArgs: [...variant.hvigorArgs],
-    moduleName: build.identity.moduleName,
-    moduleRoot: resolve(build.moduleRoot),
-    nativeCache: {
-      invalidationRoots: build.nativeCache.invalidationRoots.map(resolve),
-      stateFile: resolve(build.nativeCache.stateFile),
-    },
-    nativeInputs: {
-      lockfile: resolve(build.nativeInputs.lockfile),
-      manifest: resolve(build.nativeInputs.manifest),
-    },
-    productName: build.identity.productName,
-    projectFiles: Object.fromEntries(
-      Object.entries(build.projectFiles).map(([name, relative]) => [name, resolve(relative)])
-    ) as HarmonyBuildPlan['projectFiles'],
-    targetName: build.identity.targetName,
-  };
-}
-
-async function resolveHarmonyBuildPlanIfPresentAsync(
-  projectRoot: string,
-  options: { buildMode?: 'debug' | 'release' } = {}
-): Promise<HarmonyBuildPlan | null> {
-  const mode = options.buildMode || 'debug';
-  if (!['debug', 'release'].includes(mode)) {
-    throw new HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Harmony buildMode must be debug or release, received: ${mode}`, { operation: 'resolve-build' });
-  }
-
-  let manifest;
-
-  try {
-    manifest = await readManifestIfPresentAsync(projectRoot);
-  } catch (cause) {
-    throw new HarmonyCliError(
-      cause.code || 'ERR_HARMONY_TEMPLATE_INVALID',
-      `Cannot read the generated Harmony build descriptor: ${cause.message}`,
-      { cause, operation: 'resolve-build' }
-    );
-  }
-
-  if (!manifest) return null;
-
-  return createHarmonyBuildPlan(projectRoot, manifest.build, mode);
-}
-
-async function resolveHarmonyBuildPlanAsync(
-  projectRoot: string,
-  options: { buildMode?: 'debug' | 'release' } = {}
-): Promise<HarmonyBuildPlan> {
-  const plan = await resolveHarmonyBuildPlanIfPresentAsync(projectRoot, options);
-  if (!plan) {
-    throw new HarmonyCliError(
-      'ERR_HARMONY_MANIFEST_DRIFT',
-      'Cannot read the generated Harmony build descriptor because the CNG manifest is missing.',
-      { operation: 'resolve-build' }
-    );
-  }
-
-  return plan;
-}
-
-export {
-  createHarmonyToolchainEnv,
-  resolveHarmonyBuildPlanAsync,
-  resolveHarmonyBuildPlanIfPresentAsync,
-  resolveHarmonyEmulator,
-  resolveHarmonyToolchain,
-};
+export { createHarmonyToolchainEnv, resolveHarmonyEmulator, resolveHarmonyToolchain };

package/src/native/types.ts

@@ -0,0 +1,44 @@
+export type HarmonyBuildMode = 'debug' | 'release';
+
+interface NativeBuildPlan {
+  abilityName: string;
+  buildMode: HarmonyBuildMode;
+  bundleName: string;
+  expectedHap: string;
+  exportPaths: {
+    bundle: string;
+    manifest: string;
+    metadataRoot: string;
+    rawfileRoot: string;
+    sourceMap: string;
+  };
+  harmonyRoot: string;
+  hvigorArgs: string[];
+  moduleName: string;
+  moduleRoot: string;
+  nativeCache: { invalidationRoots: string[]; stateFile: string };
+  nativeInputs: { lockfile: string; manifest: string };
+  projectFiles: {
+    hvigorConfig: string;
+    moduleHvigor: string;
+    moduleJson: string;
+    projectBuildProfile: string;
+    rootHvigor: string;
+  };
+  productName: string;
+  targetName: string;
+}
+
+export interface BareHarmonyBuildPlan extends NativeBuildPlan {
+  workflow: 'bare';
+}
+
+export interface CngHarmonyBuildPlan extends NativeBuildPlan {
+  workflow: 'cng';
+  projectFiles: NativeBuildPlan['projectFiles'] & {
+    nativeInputsStamp: string;
+    templateMarker: string;
+  };
+}
+
+export type HarmonyBuildPlan = BareHarmonyBuildPlan | CngHarmonyBuildPlan;