@expo-harmony/cli 55.0.26-harmony.1 → 55.0.26-harmony.10

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}

@@ -1,13 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-
-import {
-  resolveHarmonyBuildPath,
-  type HarmonyBuildDescriptor,
-} from '@expo-harmony/prebuild-config/build-descriptor';
-import { readManifestIfPresentAsync } from '@expo-harmony/prebuild-config/check';
-
-import { HarmonyCliError } from './errors';
+import { resolveHarmonyCommand } from '@expo-harmony/expo-modules-autolinking/tool-command';
 
 export interface HarmonyTool {
   args: string[];
@@ -23,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;
 }
@@ -54,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);
 
@@ -74,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,
@@ -92,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 = [
@@ -104,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'),
@@ -117,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';
@@ -133,51 +113,49 @@ 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) : [];
 
   let ohpm: HarmonyTool;
   if (env.HARMONY_OHPM) {
-    ohpm = { args: [], command: env.HARMONY_OHPM, source: 'override' };
+    ohpm = { ...resolveHarmonyCommand('ohpm', [], env), source: 'override' };
   } else {
-    const devEcoOhpm = existingFile(layouts.map(layout => path.join(
+    const entry = layouts.map(layout => ({
+      node: devEcoNode(layout, platform, { ...env, HARMONY_NODE: env.HARMONY_OHPM_NODE || env.HARMONY_NODE }),
+      script: path.join(layout.toolsRoot, 'ohpm', 'bin', 'pm-cli.js'),
+    })).find(candidate => candidate.node && fs.existsSync(candidate.script));
+    const command = existingFile(layouts.map(layout => path.join(
       layout.toolsRoot,
       'ohpm',
       'bin',
       platform === 'win32' ? 'ohpm.bat' : 'ohpm'
     )));
-    ohpm = devEcoOhpm
-      ? { args: [], command: devEcoOhpm, source: 'deveco' }
-      : { args: [], command: platform === 'win32' ? 'ohpm.bat' : 'ohpm', source: 'path' };
+
+    ohpm = entry
+      ? { args: [entry.script], command: entry.node.command, source: 'deveco' }
+      : command
+        ? { args: [], command, source: 'deveco' }
+        : { args: [], command: platform === 'win32' ? 'ohpm.bat' : 'ohpm', source: 'path' };
   }
 
   let hvigor: HarmonyTool;
   if (env.HARMONY_HVIGORW) {
-    if (/\.(?:c|m)?js$/iu.test(env.HARMONY_HVIGORW)) {
-      hvigor = {
-        args: [env.HARMONY_HVIGORW],
-        command: env.HARMONY_NODE || process.execPath,
-        source: 'override',
-      };
-    } else {
-      hvigor = { args: [], command: env.HARMONY_HVIGORW, source: 'override' };
-    }
+    hvigor = { ...resolveHarmonyCommand('hvigorw', [], env), source: 'override' };
   } else {
-    const devEcoHvigor = layouts.map(layout => ({
-      layout,
-      node: devEcoNode(layout, platform, env),
+    const entry = layouts.map(layout => ({
+      node: devEcoNode(layout, platform, { ...env, HARMONY_NODE: env.HARMONY_HVIGOR_NODE || env.HARMONY_NODE }),
       script: path.join(layout.toolsRoot, 'hvigor', 'bin', 'hvigorw.js'),
     })).find(candidate => candidate.node && fs.existsSync(candidate.script));
-    hvigor = devEcoHvigor
-      ? { args: [devEcoHvigor.script], command: devEcoHvigor.node.command, source: 'deveco' }
+
+    hvigor = entry
+      ? { args: [entry.script], command: entry.node.command, source: 'deveco' }
       : { args: [], command: platform === 'win32' ? 'hvigorw.bat' : 'hvigorw', source: 'path' };
   }
 
   const toolsRoot = layouts.find(layout => (
     hvigor.args[0]?.startsWith(`${layout.toolsRoot}${path.sep}`)
+    || ohpm.args[0]?.startsWith(`${layout.toolsRoot}${path.sep}`)
     || ohpm.command.startsWith(`${layout.toolsRoot}${path.sep}`)
   ))?.toolsRoot || null;
 
@@ -201,10 +179,14 @@ function resolveHarmonyToolchain(): HarmonyToolchain {
 function createHarmonyToolchainEnv(toolchain = resolveHarmonyToolchain()): NodeJS.ProcessEnv {
   return {
     ...process.env,
-    HARMONY_OHPM: toolchain.ohpm.command,
-    // A script-based Hvigor invocation must retain both its script and Node executable.
+    HARMONY_OHPM: toolchain.ohpm.args[0] || toolchain.ohpm.command,
+    HARMONY_OHPM_NODE: toolchain.ohpm.args.length > 0 ? toolchain.ohpm.command : undefined,
+    // Script-based tools must retain both their script and Node executable.
     HARMONY_HVIGORW: toolchain.hvigor.args[0] || toolchain.hvigor.command,
-    ...(toolchain.hvigor.args.length > 0 ? { HARMONY_NODE: toolchain.hvigor.command } : {}),
+    HARMONY_HVIGOR_NODE: toolchain.hvigor.args.length > 0 ? toolchain.hvigor.command : undefined,
+    ...(toolchain.hvigor.args.length > 0
+      ? { HARMONY_NODE: toolchain.hvigor.command }
+      : toolchain.ohpm.args.length > 0 ? { HARMONY_NODE: toolchain.ohpm.command } : {}),
     ...(toolchain.sdkHome && !process.env.DEVECO_SDK_HOME
       ? { DEVECO_SDK_HOME: toolchain.sdkHome }
       : {}),
@@ -229,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;

package/src/prebuild/check.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -5,20 +6,22 @@ import path from 'node:path';
 import {
   compareAsync,
   stageAsync,
-} from '@expo-harmony/prebuild-config/check';
+} from '@expo-harmony/prebuild-config/internal';
 
 import { HarmonyCliError } from '../errors';
 import { isInside } from '../path';
 import { spawnAsync } from '../process';
 import { withHarmonyProjectLockAsync } from '../projectLock';
-import { createHarmonyToolchainEnv, resolveHarmonyBuildPlanAsync, type HarmonyBuildPlan } from '../tools';
+import { createHarmonyToolchainEnv } from '../native/toolchain';
+import { resolveHarmonyBuildPlanAsync } from '../native/project';
+import { type HarmonyBuildPlan } from '../native/types';
 import { resolveExpoCli } from '../expo';
 import { packAsync } from './template';
 
-export type { Change as CheckChange } from '@expo-harmony/prebuild-config/check';
+export type { Change as CheckChange } from '@expo-harmony/prebuild-config/internal';
 
-const IgnoredProjectDirectories = new Set(['.expo', '.git', '.hvigor', '.yarn', 'node_modules']);
-const IgnoredHarmonyGeneratedDirectories = new Set([
+const IgnoredDirectories = new Set(['.expo', '.git', '.hvigor', '.yarn', 'node_modules']);
+const GeneratedDirectories = new Set([
   '.cxx',
   '.git',
   '.hvigor',
@@ -40,7 +43,28 @@ function mirrorRoot(temp, project) {
   return path.join(temp, 'filesystem', volume, ...segments);
 }
 
-async function linkModulesAsync(source, target) {
+async function linkModuleEntryAsync(
+  source: string,
+  target: string,
+  entry: fs.Dirent
+) {
+  const directory = entry.isSymbolicLink()
+    ? (await fs.promises.stat(source)).isDirectory()
+    : entry.isDirectory();
+
+  if (process.platform === 'win32' && !directory) {
+    await fs.promises.copyFile(source, target);
+    return;
+  }
+
+  await fs.promises.symlink(
+    path.resolve(source),
+    target,
+    directory ? process.platform === 'win32' ? 'junction' : 'dir' : 'file'
+  );
+}
+
+async function linkModulesAsync(source: string, target: string) {
   await fs.promises.mkdir(target, { recursive: true });
 
   for (const entry of await fs.promises.readdir(source, { withFileTypes: true })) {
@@ -49,25 +73,18 @@ async function linkModulesAsync(source, target) {
 
     if (entry.name.startsWith('@') && entry.isDirectory() && !entry.isSymbolicLink()) {
       await fs.promises.mkdir(to);
+
       for (const child of await fs.promises.readdir(from, { withFileTypes: true })) {
-        await fs.promises.symlink(
+        await linkModuleEntryAsync(
           path.join(from, child.name),
           path.join(to, child.name),
-          process.platform === 'win32' && (child.isDirectory() || child.isSymbolicLink())
-            ? 'junction'
-            : child.isDirectory() ? 'dir' : 'file'
+          child
         );
       }
       continue;
     }
 
-    await fs.promises.symlink(
-      from,
-      to,
-      process.platform === 'win32' && (entry.isDirectory() || entry.isSymbolicLink())
-        ? 'junction'
-        : entry.isDirectory() ? 'dir' : 'file'
-    );
+    await linkModuleEntryAsync(from, to, entry);
   }
 }
 
@@ -89,16 +106,18 @@ function shouldCopyPrebuildCheckPath(
   if (!relative) return true;
 
   const segments = relative.split(path.sep);
-  if (IgnoredProjectDirectories.has(segments[0])) return false;
+  if (IgnoredDirectories.has(segments[0])) return false;
 
-  const nativeRoot = isInside(plan.harmonyRoot, source)
+  const root = isInside(plan.harmonyRoot, source)
     ? plan.harmonyRoot
     : isAppLocalHarmonyPath(project, source)
       ? path.join(project, ...segments.slice(0, 3))
       : null;
-  if (nativeRoot) {
-    const native = path.relative(nativeRoot, source).split(path.sep);
-    if (native.some(segment => IgnoredHarmonyGeneratedDirectories.has(segment))) return false;
+  if (root) {
+    const native = path.relative(root, source).split(path.sep);
+    if (GeneratedDirectories.has(native[0])
+      || (GeneratedDirectories.has(native[1])
+        && fs.existsSync(path.join(root, native[0], 'src/main/module.json5')))) return false;
   }
 
   return source !== plan.exportPaths.bundle;
@@ -112,6 +131,7 @@ async function copyAsync(
 ) {
   await fs.promises.cp(project, target, {
     recursive: true,
+    verbatimSymlinks: true,
     filter: source => shouldCopyPrebuildCheckPath(project, source, plan),
   });
 
@@ -123,16 +143,16 @@ async function copyAsync(
     });
   }
 
-  // Keep a real node_modules directory in the isolated project and link its
-  // entries. Dependency scanners then retain the isolated lexical package path
-  // (including scoped packages) instead of collapsing the entire node_modules
-  // root to the source project's realpath. The packages remain read-only and
-  // are never copied or modified by --check.
+  // Link individual packages so dependency scanners retain paths inside the mirror.
   await linkModulesAsync(modules, path.join(target, 'node_modules'));
   await stageAsync(project, target, temp);
 }
 
-async function checkUnlockedAsync(project, options: CheckOptions) {
+async function withGeneratedProjectAsync<T>(
+  project: string,
+  options: CheckOptions & { clean?: boolean; skipPatches?: boolean },
+  action: (expected: string, checksum: string) => Promise<T>
+): Promise<T> {
   project = path.resolve(project);
   const plan = await resolveHarmonyBuildPlanAsync(project);
   const temp = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'expo-harmony-check-'));
@@ -141,6 +161,8 @@ async function checkUnlockedAsync(project, options: CheckOptions) {
 
   try {
     await copyAsync(project, expected, plan, temp);
+    if (options.clean) await fs.promises.rm(path.join(expected, 'harmony'), { recursive: true, force: true });
+
     packed = await packAsync(project);
 
     const expo = resolveExpoCli(project);
@@ -159,6 +181,7 @@ async function checkUnlockedAsync(project, options: CheckOptions) {
         ...packed.env,
         ...(options.buildType ? { EXPO_HARMONY_BUILD_TYPE: options.buildType } : {}),
         EXPO_HARMONY_CHECK_MIRROR_ROOT: temp,
+        ...(options.skipPatches ? { EXPO_HARMONY_SKIP_PATCHES: '1' } : {}),
       },
       operation: 'check-prebuild',
     });
@@ -171,7 +194,9 @@ async function checkUnlockedAsync(project, options: CheckOptions) {
       );
     }
 
-    return compareAsync(project, expected);
+    const checksum = createHash('md5').update(Uint8Array.from(await fs.promises.readFile(packed.tarball))).digest('hex');
+
+    return await action(expected, checksum);
   } finally {
     if (packed) await packed.cleanup();
     await fs.promises.rm(temp, { recursive: true, force: true });
@@ -182,8 +207,8 @@ async function checkAsync(project, options: CheckOptions = {}) {
   return withHarmonyProjectLockAsync(
     project,
     'prebuild-check',
-    () => checkUnlockedAsync(project, options)
+    () => withGeneratedProjectAsync(project, options, expected => compareAsync(project, expected))
   );
 }
 
-export { checkAsync };
+export { checkAsync, withGeneratedProjectAsync };