expo-harmony-toolkit 1.7.1 → 1.7.3

package/build/core/build.js

@@ -3,46 +3,63 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderBuildReport = void 0;
 exports.bundleProject = bundleProject;
 exports.buildHapProject = buildHapProject;
-exports.renderBuildReport = renderBuildReport;
 exports.getDesiredHarmonyScripts = getDesiredHarmonyScripts;
-const node_child_process_1 = require("node:child_process");
-const node_util_1 = require("node:util");
 const fs_extra_1 = __importDefault(require("fs-extra"));
-const json5_1 = __importDefault(require("json5"));
-const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const constants_1 = require("./constants");
 const env_1 = require("./env");
 const javascriptDependencies_1 = require("./javascriptDependencies");
 const project_1 = require("./project");
 const template_1 = require("./template");
-const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
-const RNOH_GENERATED_TS_SHIM_RELATIVE_PATH = path_1.default.join('oh_modules', '@rnoh', 'react-native-openharmony', 'ts.ts');
-const RNOH_GENERATED_MODULE_ROOT_RELATIVE_PATH = path_1.default.join('oh_modules', '@rnoh', 'react-native-openharmony');
-const RNOH_NORMALIZED_TS_TARGET_RELATIVE_PATH = path_1.default.join('expo-harmony-local-deps', 'rnoh-react-native-openharmony-react_native_openharmony', 'ts.ts');
-const RNOH_CLI_AUTOLINKING_TEMPLATE_RELATIVE_PATHS = [
-    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'dist', 'autolinking', 'Autolinking.js'),
-    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'src', 'autolinking', 'Autolinking.ts'),
-];
+const autolinking_1 = require("./autolinking");
+const localHar_1 = require("./build/localHar");
+const commands_1 = require("./build/commands");
+const reporting_1 = require("./build/reporting");
+const rnohCompatibility_1 = require("./build/rnohCompatibility");
+var reporting_2 = require("./build/reporting");
+Object.defineProperty(exports, "renderBuildReport", { enumerable: true, get: function () { return reporting_2.renderBuildReport; } });
 async function bundleProject(projectRoot, options = {}) {
     const runtimeEnv = options.env ?? process.env;
-    const runCommand = options.runner ?? defaultCommandRunner;
+    const runCommand = options.runner ?? commands_1.defaultCommandRunner;
     const loadedProject = await (0, project_1.loadProject)(projectRoot);
-    const bundleOutputPath = path_1.default.join(loadedProject.projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'bundle.harmony.js');
-    const assetsDestPath = path_1.default.join(loadedProject.projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'assets');
+    const bundleOutputPath = (0, reporting_1.getBundleOutputPath)(loadedProject.projectRoot);
+    const assetsDestPath = (0, reporting_1.getAssetsOutputPath)(loadedProject.projectRoot);
     const entryFileName = (0, template_1.resolveHarmonyBundleEntryFile)(loadedProject.packageJson);
     const entryFilePath = path_1.default.join(loadedProject.projectRoot, entryFileName);
     const metroConfigPath = path_1.default.join(loadedProject.projectRoot, 'metro.harmony.config.js');
     const reactNativeCliPath = path_1.default.join(loadedProject.projectRoot, 'node_modules', 'react-native', 'cli.js');
     const warnings = [];
     const blockingIssues = [];
-    const syncResult = await (0, template_1.syncProjectTemplate)(loadedProject.projectRoot, false, {
-        forceManagedPaths: template_1.BUILD_REQUIRED_MANAGED_FILE_PATHS,
-        skipJavaScriptDependencyNormalization: options.skipTemplateSync,
-    });
-    warnings.push(...syncResult.warnings);
+    try {
+        const syncResult = await (0, template_1.syncProjectTemplate)(loadedProject.projectRoot, false, {
+            forceManagedPaths: template_1.BUILD_REQUIRED_MANAGED_FILE_PATHS,
+            skipJavaScriptDependencyNormalization: options.skipTemplateSync,
+        });
+        warnings.push(...syncResult.warnings);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return (0, reporting_1.createBuildReport)({
+            projectRoot: loadedProject.projectRoot,
+            command: 'bundle',
+            mode: null,
+            status: 'failed',
+            entryFile: entryFilePath,
+            bundleOutputPath,
+            assetsDestPath,
+            artifactPaths: [],
+            blockingIssues: [
+                {
+                    code: 'build.bundle.failed',
+                    message,
+                },
+            ],
+            warnings,
+            steps: [],
+        });
+    }
     if (!(await fs_extra_1.default.pathExists(reactNativeCliPath))) {
         blockingIssues.push({
             code: 'build.bundle.failed',
@@ -61,7 +78,7 @@ async function bundleProject(projectRoot, options = {}) {
             message: 'metro.harmony.config.js is missing. Run expo-harmony init first.',
         });
     }
-    const initialReport = createBuildReport({
+    const initialReport = (0, reporting_1.createBuildReport)({
         projectRoot: loadedProject.projectRoot,
         command: 'bundle',
         mode: null,
@@ -90,7 +107,7 @@ async function bundleProject(projectRoot, options = {}) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        return createBuildReport({
+        return (0, reporting_1.createBuildReport)({
             projectRoot: loadedProject.projectRoot,
             command: 'bundle',
             mode: null,
@@ -124,17 +141,17 @@ async function bundleProject(projectRoot, options = {}) {
         '--config',
         metroConfigPath,
     ];
-    const bundleCommand = buildInvocation(process.execPath, bundleArgs);
+    const bundleCommand = (0, commands_1.buildInvocation)(process.execPath, bundleArgs);
     try {
         const bundleResult = await runCommand(bundleCommand.file, bundleCommand.args, {
             cwd: loadedProject.projectRoot,
             env: bundleEnvironment,
         });
         const steps = [
-            createStepReport('bundle-harmony', bundleCommand.file, bundleCommand.args, loadedProject.projectRoot, bundleResult.exitCode),
+            (0, reporting_1.createStepReport)('bundle-harmony', bundleCommand.file, bundleCommand.args, loadedProject.projectRoot, bundleResult.exitCode),
         ];
         if (bundleResult.exitCode !== 0 || !(await fs_extra_1.default.pathExists(bundleOutputPath))) {
-            return createBuildReport({
+            return (0, reporting_1.createBuildReport)({
                 projectRoot: loadedProject.projectRoot,
                 command: 'bundle',
                 mode: null,
@@ -155,7 +172,7 @@ async function bundleProject(projectRoot, options = {}) {
                 steps,
             });
         }
-        return createBuildReport({
+        return (0, reporting_1.createBuildReport)({
             projectRoot: loadedProject.projectRoot,
             command: 'bundle',
             mode: null,
@@ -175,14 +192,15 @@ async function bundleProject(projectRoot, options = {}) {
 }
 async function buildHapProject(projectRoot, options) {
     const runtimeEnv = options.env ?? process.env;
-    const runCommand = options.runner ?? defaultCommandRunner;
+    const runCommand = options.runner ?? commands_1.defaultCommandRunner;
     const loadedProject = await (0, project_1.loadProject)(projectRoot);
     const envReport = await (0, env_1.buildEnvReport)(loadedProject.projectRoot, {
         env: runtimeEnv,
     });
+    const relevantEnvAdvisories = envReport.advisories.filter((issue) => options.mode === 'release' || issue.code !== 'env.signing.missing');
     const warnings = [
         ...envReport.warnings.filter((warning) => !warning.startsWith('Harmony sidecar files are not present yet.')),
-        ...envReport.advisories.map((issue) => `${issue.code}: ${issue.message}`),
+        ...relevantEnvAdvisories.map((issue) => `${issue.code}: ${issue.message}`),
     ];
     const blockingIssues = [];
     if (!envReport.hvigorPath) {
@@ -200,18 +218,18 @@ async function buildHapProject(projectRoot, options) {
     if (options.mode === 'release' && !envReport.signingConfigured) {
         blockingIssues.push({
             code: 'env.signing.missing',
-            message: 'Release HAP builds require signingConfigs from .expo-harmony/signing.local.json or harmony/build-profile.json5.',
+            message: 'Release HAP builds require signingConfigs from .expo-harmony/signing.local.json or harmony/build-profile.json5. Start from .expo-harmony/signing.local.example.json and replace the placeholder credentials.',
         });
     }
     if (blockingIssues.length > 0) {
-        return createBuildReport({
+        return (0, reporting_1.createBuildReport)({
             projectRoot: loadedProject.projectRoot,
             command: 'build-hap',
             mode: options.mode,
             status: 'failed',
             entryFile: path_1.default.join(loadedProject.projectRoot, (0, template_1.resolveHarmonyBundleEntryFile)(loadedProject.packageJson)),
-            bundleOutputPath: getBundleOutputPath(loadedProject.projectRoot),
-            assetsDestPath: getAssetsOutputPath(loadedProject.projectRoot),
+            bundleOutputPath: (0, reporting_1.getBundleOutputPath)(loadedProject.projectRoot),
+            assetsDestPath: (0, reporting_1.getAssetsOutputPath)(loadedProject.projectRoot),
             artifactPaths: [],
             blockingIssues,
             warnings,
@@ -224,7 +242,7 @@ async function buildHapProject(projectRoot, options) {
     });
     const harmonyProjectRoot = envReport.harmonyProjectRoot ?? path_1.default.join(loadedProject.projectRoot, 'harmony');
     if (bundleReport.status === 'failed') {
-        return createBuildReport({
+        return (0, reporting_1.createBuildReport)({
             projectRoot: loadedProject.projectRoot,
             command: 'build-hap',
             mode: options.mode,
@@ -240,7 +258,7 @@ async function buildHapProject(projectRoot, options) {
         });
     }
     if (!(await fs_extra_1.default.pathExists(harmonyProjectRoot))) {
-        return createBuildReport({
+        return (0, reporting_1.createBuildReport)({
             projectRoot: loadedProject.projectRoot,
             command: 'build-hap',
             mode: options.mode,
@@ -261,7 +279,7 @@ async function buildHapProject(projectRoot, options) {
         });
     }
     const steps = [...bundleReport.steps];
-    const buildEnvironment = createHarmonyBuildEnvironment(runtimeEnv, envReport);
+    const buildEnvironment = (0, commands_1.createHarmonyBuildEnvironment)(runtimeEnv, envReport);
     let normalizedLocalHarPackages = [];
     let restoreNormalizedDependencies = async () => { };
     let restoreNormalizedLocalHarModules = async () => { };
@@ -269,18 +287,18 @@ async function buildHapProject(projectRoot, options) {
     let restoreNormalizedRnohCodegenAlignment = async () => { };
     let restoreNormalizedHarmonyPackageJsons = async () => { };
     try {
-        const normalizedLocalHarDependencies = await normalizeLocalHarDependencies(harmonyProjectRoot);
+        const normalizedLocalHarDependencies = await (0, localHar_1.normalizeLocalHarDependencies)(harmonyProjectRoot);
         normalizedLocalHarPackages = normalizedLocalHarDependencies.packages;
         restoreNormalizedDependencies = normalizedLocalHarDependencies.restore;
-        restoreNormalizedLocalHarModules = await ensureHarmonyBuildProfileSupportsNormalizedLocalDeps(harmonyProjectRoot, normalizedLocalHarDependencies.packages);
+        restoreNormalizedLocalHarModules = await (0, localHar_1.ensureHarmonyBuildProfileSupportsNormalizedLocalDeps)(harmonyProjectRoot, normalizedLocalHarDependencies.packages);
         restoreNormalizedRnohCliAutolinkingTemplates =
-            await normalizeProjectRnohCliAutolinkingTemplates(loadedProject.projectRoot);
+            await (0, rnohCompatibility_1.normalizeProjectRnohCliAutolinkingTemplates)(loadedProject.projectRoot);
         restoreNormalizedHarmonyPackageJsons =
-            await (0, template_1.normalizeKnownHarmonyPackageJsons)(loadedProject.projectRoot);
+            await (0, autolinking_1.normalizeKnownHarmonyPackageJsons)(loadedProject.projectRoot);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        return createBuildReport({
+        return (0, reporting_1.createBuildReport)({
             projectRoot: loadedProject.projectRoot,
             command: 'build-hap',
             mode: options.mode,
@@ -300,16 +318,16 @@ async function buildHapProject(projectRoot, options) {
             steps,
         });
     }
-    restoreNormalizedRnohCodegenAlignment = await alignRnohCodegenWithNormalizedLocalPackage(harmonyProjectRoot, normalizedLocalHarPackages);
-    const ohpmCommand = buildInvocation(envReport.ohpmPath, ['install', '--all']);
+    restoreNormalizedRnohCodegenAlignment = await (0, localHar_1.alignRnohCodegenWithNormalizedLocalPackage)(harmonyProjectRoot, normalizedLocalHarPackages);
+    const ohpmCommand = (0, commands_1.buildInvocation)(envReport.ohpmPath, ['install', '--all']);
     try {
         const ohpmResult = await runCommand(ohpmCommand.file, ohpmCommand.args, {
             cwd: harmonyProjectRoot,
             env: buildEnvironment,
         });
-        steps.push(createStepReport('ohpm install', ohpmCommand.file, ohpmCommand.args, harmonyProjectRoot, ohpmResult.exitCode));
+        steps.push((0, reporting_1.createStepReport)('ohpm install', ohpmCommand.file, ohpmCommand.args, harmonyProjectRoot, ohpmResult.exitCode));
         if (ohpmResult.exitCode !== 0) {
-            return createBuildReport({
+            return (0, reporting_1.createBuildReport)({
                 projectRoot: loadedProject.projectRoot,
                 command: 'build-hap',
                 mode: options.mode,
@@ -332,9 +350,9 @@ async function buildHapProject(projectRoot, options) {
             });
         }
         if (!normalizedLocalHarPackages.some((localPackage) => localPackage.packageName === '@rnoh/react-native-openharmony')) {
-            await ensureRnohGeneratedTsShim(harmonyProjectRoot);
+            await (0, localHar_1.ensureRnohGeneratedTsShim)(harmonyProjectRoot);
         }
-        const hvigorCommand = buildInvocation(envReport.hvigorPath, [
+        const hvigorCommand = (0, commands_1.buildInvocation)(envReport.hvigorPath, [
             'assembleHap',
             '--no-daemon',
             '-p',
@@ -346,10 +364,10 @@ async function buildHapProject(projectRoot, options) {
             cwd: harmonyProjectRoot,
             env: buildEnvironment,
         });
-        steps.push(createStepReport('hvigor assembleHap', hvigorCommand.file, hvigorCommand.args, harmonyProjectRoot, hvigorResult.exitCode));
-        const artifactPaths = await findHarmonyArtifacts(harmonyProjectRoot);
+        steps.push((0, reporting_1.createStepReport)('hvigor assembleHap', hvigorCommand.file, hvigorCommand.args, harmonyProjectRoot, hvigorResult.exitCode));
+        const artifactPaths = await (0, localHar_1.findHarmonyArtifacts)(harmonyProjectRoot);
         if (hvigorResult.exitCode !== 0 || artifactPaths.length === 0) {
-            return createBuildReport({
+            return (0, reporting_1.createBuildReport)({
                 projectRoot: loadedProject.projectRoot,
                 command: 'build-hap',
                 mode: options.mode,
@@ -371,7 +389,7 @@ async function buildHapProject(projectRoot, options) {
                 steps,
             });
         }
-        return createBuildReport({
+        return (0, reporting_1.createBuildReport)({
             projectRoot: loadedProject.projectRoot,
             command: 'build-hap',
             mode: options.mode,
@@ -394,716 +412,6 @@ async function buildHapProject(projectRoot, options) {
         await restoreNormalizedDependencies();
     }
 }
-function renderBuildReport(report) {
-    const lines = [
-        'Expo Harmony build report',
-        `Project: ${report.projectRoot}`,
-        `Command: ${report.command}`,
-        `Mode: ${report.mode ?? 'n/a'}`,
-        `Status: ${report.status}`,
-        `Harmony project: ${report.harmonyProjectRoot ?? 'not found'}`,
-        `Entry file: ${report.entryFile ?? 'n/a'}`,
-        `Bundle output: ${report.bundleOutputPath ?? 'n/a'}`,
-        `Artifacts: ${report.artifactPaths.join(', ') || 'none'}`,
-        '',
-        'Steps:',
-        ...report.steps.map((step) => `- [${step.exitCode ?? 'n/a'}] ${step.label}: ${step.command} (cwd ${step.cwd})`),
-    ];
-    if (report.blockingIssues.length > 0) {
-        lines.push('', 'Blocking issues:', ...report.blockingIssues.map((issue) => `- ${issue.code}: ${issue.message}${issue.subject ? ` (${issue.subject})` : ''}`));
-    }
-    if (report.warnings.length > 0) {
-        lines.push('', 'Warnings:', ...report.warnings.map((warning) => `- ${warning}`));
-    }
-    return lines.join('\n');
-}
-function getBundleOutputPath(projectRoot) {
-    return path_1.default.join(projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'bundle.harmony.js');
-}
-function getAssetsOutputPath(projectRoot) {
-    return path_1.default.join(projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'assets');
-}
-function createBuildReport(input) {
-    return {
-        generatedAt: new Date().toISOString(),
-        projectRoot: input.projectRoot,
-        toolkitVersion: constants_1.TOOLKIT_VERSION,
-        command: input.command,
-        mode: input.mode,
-        status: input.status,
-        harmonyProjectRoot: input.harmonyProjectRoot ?? path_1.default.join(input.projectRoot, 'harmony'),
-        entryFile: input.entryFile,
-        bundleOutputPath: input.bundleOutputPath,
-        assetsDestPath: input.assetsDestPath,
-        artifactPaths: input.artifactPaths,
-        blockingIssues: input.blockingIssues,
-        warnings: input.warnings,
-        steps: input.steps,
-    };
-}
-function createStepReport(label, file, args, cwd, exitCode) {
-    return {
-        label,
-        command: [file, ...args].join(' '),
-        cwd,
-        exitCode,
-    };
-}
-function buildInvocation(file, args) {
-    if (file.endsWith('.js')) {
-        return {
-            file: process.execPath,
-            args: [file, ...args],
-        };
-    }
-    return {
-        file,
-        args,
-    };
-}
-function createHarmonyBuildEnvironment(runtimeEnv, envReport) {
-    const buildEnvironment = {
-        ...runtimeEnv,
-    };
-    if (envReport.sdkRoot) {
-        buildEnvironment.DEVECO_SDK_HOME = envReport.sdkRoot;
-        buildEnvironment.OHOS_BASE_SDK_HOME = envReport.sdkRoot;
-    }
-    if (envReport.devecoStudioPath) {
-        buildEnvironment.NODE_HOME =
-            buildEnvironment.NODE_HOME ??
-                path_1.default.join(envReport.devecoStudioPath, 'Contents', 'tools', 'node');
-    }
-    return buildEnvironment;
-}
-async function normalizeLocalHarDependencies(harmonyProjectRoot) {
-    const packagePaths = [
-        path_1.default.join(harmonyProjectRoot, 'oh-package.json5'),
-        path_1.default.join(harmonyProjectRoot, 'entry', 'oh-package.json5'),
-    ];
-    const extractionRoot = path_1.default.join(harmonyProjectRoot, 'expo-harmony-local-deps');
-    const archiveCache = new Map();
-    const originalContents = new Map();
-    const packagesByDirectoryPath = new Map();
-    await fs_extra_1.default.ensureDir(extractionRoot);
-    for (const packagePath of packagePaths) {
-        if (!(await fs_extra_1.default.pathExists(packagePath))) {
-            continue;
-        }
-        const rawContents = await fs_extra_1.default.readFile(packagePath, 'utf8');
-        const parsed = json5_1.default.parse(rawContents);
-        let didChange = false;
-        for (const sectionName of ['dependencies', 'devDependencies', 'overrides']) {
-            const section = parsed[sectionName];
-            if (!section || typeof section !== 'object' || Array.isArray(section)) {
-                continue;
-            }
-            for (const [packageName, specifier] of Object.entries(section)) {
-                if (typeof specifier !== 'string' || !specifier.startsWith('file:') || !specifier.endsWith('.har')) {
-                    continue;
-                }
-                const archivePath = path_1.default.resolve(harmonyProjectRoot, specifier.slice('file:'.length));
-                const normalizedDirectory = archiveCache.get(archivePath) ??
-                    (await extractHarArchiveToDirectory(archivePath, extractionRoot, packageName));
-                archiveCache.set(archivePath, normalizedDirectory);
-                if (!packagesByDirectoryPath.has(normalizedDirectory)) {
-                    packagesByDirectoryPath.set(normalizedDirectory, await readNormalizedLocalHarPackageMetadata(normalizedDirectory, packageName));
-                }
-                let relativeDirectory = path_1.default.relative(harmonyProjectRoot, normalizedDirectory);
-                if (!relativeDirectory.startsWith('.')) {
-                    relativeDirectory = `./${relativeDirectory}`;
-                }
-                const nextSpecifier = `file:${relativeDirectory.split(path_1.default.sep).join('/')}`;
-                if (nextSpecifier !== specifier) {
-                    section[packageName] = nextSpecifier;
-                    didChange = true;
-                }
-            }
-        }
-        if (didChange) {
-            originalContents.set(packagePath, rawContents);
-            await fs_extra_1.default.writeFile(packagePath, JSON.stringify(parsed, null, 2) + '\n');
-        }
-    }
-    return {
-        packages: [...packagesByDirectoryPath.values()],
-        restore: async () => {
-            for (const [packagePath, rawContents] of originalContents) {
-                await fs_extra_1.default.writeFile(packagePath, rawContents);
-            }
-        },
-    };
-}
-async function extractHarArchiveToDirectory(archivePath, extractionRoot, packageName) {
-    if (!(await fs_extra_1.default.pathExists(archivePath))) {
-        throw new Error(`Local Harmony archive not found: ${archivePath}`);
-    }
-    const destinationPath = path_1.default.join(extractionRoot, `${sanitizePackageName(packageName)}-${path_1.default.basename(archivePath, path_1.default.extname(archivePath))}`);
-    const stagingRoot = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'expo-harmony-har-'));
-    try {
-        await execFileAsync('tar', ['-xzf', archivePath, '-C', stagingRoot], {
-            maxBuffer: 20 * 1024 * 1024,
-        });
-        const packagedRoot = path_1.default.join(stagingRoot, 'package');
-        const sourceRoot = (await fs_extra_1.default.pathExists(path_1.default.join(packagedRoot, 'oh-package.json5')))
-            ? packagedRoot
-            : stagingRoot;
-        if (!(await fs_extra_1.default.pathExists(path_1.default.join(sourceRoot, 'oh-package.json5')))) {
-            throw new Error(`oh-package.json5 not found after extracting ${archivePath}`);
-        }
-        await fs_extra_1.default.remove(destinationPath);
-        await fs_extra_1.default.ensureDir(destinationPath);
-        for (const entryName of await fs_extra_1.default.readdir(sourceRoot)) {
-            await fs_extra_1.default.move(path_1.default.join(sourceRoot, entryName), path_1.default.join(destinationPath, entryName), {
-                overwrite: true,
-            });
-        }
-        await ensureNormalizedLocalHarCompatibilityShims(destinationPath, packageName);
-        return destinationPath;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to normalize local Harmony archive ${archivePath}: ${message}`);
-    }
-    finally {
-        await fs_extra_1.default.remove(stagingRoot);
-    }
-}
-async function ensureNormalizedLocalHarCompatibilityShims(directoryPath, packageName) {
-    if (packageName === '@react-native-oh-tpl/react-native-gesture-handler') {
-        const gestureHandlerPackageHeaderPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'RnohReactNativeHarmonyGestureHandlerPackage.h');
-        const gestureHandlerPackagePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'RnohReactNativeHarmonyGestureHandlerPackage.cpp');
-        const gestureHandlerTurboModulePath = path_1.default.join(directoryPath, 'src', 'main', 'ets', 'rnoh', 'RNGestureHandlerModule.ts');
-        if (await fs_extra_1.default.pathExists(gestureHandlerTurboModulePath)) {
-            const gestureHandlerTurboModuleContents = await fs_extra_1.default.readFile(gestureHandlerTurboModulePath, 'utf8');
-            let nextGestureHandlerTurboModuleContents = gestureHandlerTurboModuleContents;
-            nextGestureHandlerTurboModuleContents = nextGestureHandlerTurboModuleContents.replace(/^import \{ TM \} from ["']@rnoh\/react-native-openharmony\/generated\/ts["'];?\r?\n/m, '');
-            nextGestureHandlerTurboModuleContents = nextGestureHandlerTurboModuleContents.replace(/\s+implements TM\.RNGestureHandlerModule\.Spec/, '');
-            if (nextGestureHandlerTurboModuleContents !== gestureHandlerTurboModuleContents) {
-                await fs_extra_1.default.writeFile(gestureHandlerTurboModulePath, nextGestureHandlerTurboModuleContents);
-            }
-        }
-        const gestureHandlerGeneratedDirectoryPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'generated');
-        await fs_extra_1.default.ensureDir(gestureHandlerGeneratedDirectoryPath);
-        await fs_extra_1.default.writeFile(path_1.default.join(gestureHandlerGeneratedDirectoryPath, 'RNGestureHandlerButtonComponentDescriptor.h'), createGestureHandlerCompatibilityDescriptorHeader('RNGestureHandlerButton'));
-        await fs_extra_1.default.writeFile(path_1.default.join(gestureHandlerGeneratedDirectoryPath, 'RNGestureHandlerRootViewComponentDescriptor.h'), createGestureHandlerCompatibilityDescriptorHeader('RNGestureHandlerRootView'));
-        if (await fs_extra_1.default.pathExists(gestureHandlerPackageHeaderPath)) {
-            const gestureHandlerPackageHeaderContents = await fs_extra_1.default.readFile(gestureHandlerPackageHeaderPath, 'utf8');
-            const nextGestureHandlerPackageHeaderContents = patchGestureHandlerCompatibilityPackageHeader(gestureHandlerPackageHeaderContents);
-            if (nextGestureHandlerPackageHeaderContents !== gestureHandlerPackageHeaderContents) {
-                await fs_extra_1.default.writeFile(gestureHandlerPackageHeaderPath, nextGestureHandlerPackageHeaderContents);
-            }
-        }
-        if (!(await fs_extra_1.default.pathExists(gestureHandlerPackagePath))) {
-            return;
-        }
-        const gestureHandlerPackageContents = await fs_extra_1.default.readFile(gestureHandlerPackagePath, 'utf8');
-        const nextGestureHandlerPackageContents = patchGestureHandlerCompatibilityPackageSource(gestureHandlerPackageContents);
-        if (nextGestureHandlerPackageContents !== gestureHandlerPackageContents) {
-            await fs_extra_1.default.writeFile(gestureHandlerPackagePath, nextGestureHandlerPackageContents);
-        }
-        if (!nextGestureHandlerPackageContents.includes('<react/renderer/debug/SystraceSection.h>')) {
-            return;
-        }
-        const systraceCompatibilityShimPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'react', 'renderer', 'debug', 'SystraceSection.h');
-        await fs_extra_1.default.ensureDir(path_1.default.dirname(systraceCompatibilityShimPath));
-        await fs_extra_1.default.writeFile(systraceCompatibilityShimPath, '#pragma once\n#include <cxxreact/SystraceSection.h>\n');
-        return;
-    }
-    if (packageName === '@react-native-oh-tpl/react-native-reanimated') {
-        const reanimatedCmakeListsPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'CMakeLists.txt');
-        const reanimatedMountHookHeaderPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'Common', 'cpp', 'Fabric', 'ReanimatedMountHook.h');
-        const reanimatedMountHookSourcePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'Common', 'cpp', 'Fabric', 'ReanimatedMountHook.cpp');
-        const nativeReanimatedModuleSourcePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'Common', 'cpp', 'NativeModules', 'NativeReanimatedModule.cpp');
-        if (await fs_extra_1.default.pathExists(reanimatedCmakeListsPath)) {
-            const reanimatedCmakeListsContents = await fs_extra_1.default.readFile(reanimatedCmakeListsPath, 'utf8');
-            if (reanimatedCmakeListsContents.includes('REACT_NATIVE_MINOR_VERSION=72')) {
-                await fs_extra_1.default.writeFile(reanimatedCmakeListsPath, reanimatedCmakeListsContents.replace('REACT_NATIVE_MINOR_VERSION=72', 'REACT_NATIVE_MINOR_VERSION=82'));
-            }
-        }
-        if (await fs_extra_1.default.pathExists(reanimatedMountHookHeaderPath)) {
-            const reanimatedMountHookHeaderContents = await fs_extra_1.default.readFile(reanimatedMountHookHeaderPath, 'utf8');
-            if (reanimatedMountHookHeaderContents.includes('double mountTime) noexcept override;')) {
-                await fs_extra_1.default.writeFile(reanimatedMountHookHeaderPath, reanimatedMountHookHeaderContents.replace('double mountTime) noexcept override;', 'HighResTimeStamp mountTime) noexcept override;'));
-            }
-        }
-        if (await fs_extra_1.default.pathExists(reanimatedMountHookSourcePath)) {
-            const reanimatedMountHookSourceContents = await fs_extra_1.default.readFile(reanimatedMountHookSourcePath, 'utf8');
-            if (reanimatedMountHookSourceContents.includes('double) noexcept {')) {
-                await fs_extra_1.default.writeFile(reanimatedMountHookSourcePath, reanimatedMountHookSourceContents.replace('double) noexcept {', 'HighResTimeStamp) noexcept {'));
-            }
-        }
-        if (await fs_extra_1.default.pathExists(nativeReanimatedModuleSourcePath)) {
-            const nativeReanimatedModuleSourceContents = await fs_extra_1.default.readFile(nativeReanimatedModuleSourcePath, 'utf8');
-            let nextNativeReanimatedModuleSourceContents = nativeReanimatedModuleSourceContents;
-            if (nextNativeReanimatedModuleSourceContents.includes('<react/renderer/core/TraitCast.h>')) {
-                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace('<react/renderer/core/TraitCast.h>', '<react/renderer/core/LayoutableShadowNode.h>');
-            }
-            if (nextNativeReanimatedModuleSourceContents.includes('#include <react/utils/CoreFeatures.h>')) {
-                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace('#include <react/utils/CoreFeatures.h>\n', '');
-                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace('#include <react/utils/CoreFeatures.h>\r\n', '');
-            }
-            if (nextNativeReanimatedModuleSourceContents.includes('traitCast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get())')) {
-                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace('traitCast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get())', 'dynamic_cast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get())');
-            }
-            if (nextNativeReanimatedModuleSourceContents.includes('shadowNodeFromValue(rt, shadowNodeWrapper)')) {
-                nextNativeReanimatedModuleSourceContents =
-                    nextNativeReanimatedModuleSourceContents.replace(/auto (\w+) = shadowNodeFromValue\(rt, shadowNodeWrapper\);/g, 'auto $1 = Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, shadowNodeWrapper);');
-            }
-            if (nextNativeReanimatedModuleSourceContents.includes('shadowNodeFromValue(rt, shadowNodeValue)')) {
-                nextNativeReanimatedModuleSourceContents =
-                    nextNativeReanimatedModuleSourceContents.replace(/(ShadowNode::Shared|auto) (\w+) = shadowNodeFromValue\(rt, shadowNodeValue\);/g, 'auto $2 = Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, shadowNodeValue);');
-            }
-            if (nextNativeReanimatedModuleSourceContents.includes('bool CoreFeatures::useNativeState;')) {
-                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace(/#if REACT_NATIVE_MINOR_VERSION >= 73 && defined\(RCT_NEW_ARCH_ENABLED\)\r?\n\/\/ Android can't find the definition of this static field\r?\nbool CoreFeatures::useNativeState;\r?\n#endif\r?\n/m, '');
-            }
-            if (nextNativeReanimatedModuleSourceContents.includes('/* .shouldYield = */ [this]() {')) {
-                nextNativeReanimatedModuleSourceContents =
-                    nextNativeReanimatedModuleSourceContents.replace(/#if REACT_NATIVE_MINOR_VERSION >= 72\r?\n\s*\/\* \.mountSynchronously = \*\/ true,\r?\n#endif\r?\n\s*\/\* \.shouldYield = \*\/ \[this\]\(\) \{\r?\n\s*return propsRegistry_->shouldReanimatedSkipCommit\(\);\r?\n\s*\}/m, '#if REACT_NATIVE_MINOR_VERSION >= 72\n'
-                        + '              /* .mountSynchronously = */ true,\n'
-                        + '#endif\n'
-                        + '              /* .source = */ ShadowTree::CommitSource::Unknown');
-            }
-            if (nextNativeReanimatedModuleSourceContents !== nativeReanimatedModuleSourceContents) {
-                await fs_extra_1.default.writeFile(nativeReanimatedModuleSourcePath, nextNativeReanimatedModuleSourceContents);
-            }
-        }
-        return;
-    }
-    if (packageName !== '@react-native-oh-tpl/react-native-svg') {
-        return;
-    }
-    const svgGeneratedPropsPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'generated', 'react', 'renderer', 'components', 'react_native_svg', 'Props.h');
-    const svgPathComponentInstancePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'componentInstances', 'RNSVGPathComponentInstance.h');
-    const svgImageComponentDescriptorPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'svgImage', 'RNSVGImageComponentDescriptor.h');
-    const svgImageShadowNodePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'svgImage', 'RNSVGImageShadowNode.h');
-    if (await fs_extra_1.default.pathExists(svgGeneratedPropsPath)) {
-        const svgGeneratedPropsContents = await fs_extra_1.default.readFile(svgGeneratedPropsPath, 'utf8');
-        if (svgGeneratedPropsContents.includes('butter::map<std::string, RawValue>')) {
-            await fs_extra_1.default.writeFile(svgGeneratedPropsPath, svgGeneratedPropsContents.replace(/butter::map<std::string, RawValue>/g, 'std::unordered_map<std::string, RawValue>'));
-        }
-    }
-    if (await fs_extra_1.default.pathExists(svgImageComponentDescriptorPath)) {
-        const svgImageComponentDescriptorContents = await fs_extra_1.default.readFile(svgImageComponentDescriptorPath, 'utf8');
-        let nextSvgImageComponentDescriptorContents = svgImageComponentDescriptorContents;
-        if (nextSvgImageComponentDescriptorContents.includes('void adopt(ShadowNode::Unshared const &shadowNode) const override {')) {
-            nextSvgImageComponentDescriptorContents =
-                nextSvgImageComponentDescriptorContents.replace('void adopt(ShadowNode::Unshared const &shadowNode) const override {', 'void adopt(ShadowNode& shadowNode) const override {');
-        }
-        if (nextSvgImageComponentDescriptorContents.includes('auto imageShadowNode = std::static_pointer_cast<RNSVGImageShadowNode>(shadowNode);')) {
-            nextSvgImageComponentDescriptorContents =
-                nextSvgImageComponentDescriptorContents.replace('auto imageShadowNode = std::static_pointer_cast<RNSVGImageShadowNode>(shadowNode);', 'auto& imageShadowNode = static_cast<RNSVGImageShadowNode&>(shadowNode);');
-        }
-        if (nextSvgImageComponentDescriptorContents.includes('imageShadowNode->setImageManager(imageManager_);')) {
-            nextSvgImageComponentDescriptorContents =
-                nextSvgImageComponentDescriptorContents.replace('imageShadowNode->setImageManager(imageManager_);', 'imageShadowNode.setImageManager(imageManager_);');
-        }
-        if (nextSvgImageComponentDescriptorContents !== svgImageComponentDescriptorContents) {
-            await fs_extra_1.default.writeFile(svgImageComponentDescriptorPath, nextSvgImageComponentDescriptorContents);
-        }
-    }
-    if (await fs_extra_1.default.pathExists(svgImageShadowNodePath)) {
-        const svgImageShadowNodeContents = await fs_extra_1.default.readFile(svgImageShadowNodePath, 'utf8');
-        let nextSvgImageShadowNodeContents = svgImageShadowNodeContents;
-        const svgImageShadowNodeNewline = svgImageShadowNodeContents.includes('\r\n') ? '\r\n' : '\n';
-        if (!nextSvgImageShadowNodeContents.includes('#include <react/renderer/core/ShadowNodeFamily.h>')
-            && nextSvgImageShadowNodeContents.includes('#include <react/renderer/components/view/ConcreteViewShadowNode.h>')) {
-            nextSvgImageShadowNodeContents = nextSvgImageShadowNodeContents.replace('#include <react/renderer/components/view/ConcreteViewShadowNode.h>', '#include <react/renderer/components/view/ConcreteViewShadowNode.h>'
-                + `${svgImageShadowNodeNewline}#include <react/renderer/core/ShadowNodeFamily.h>`);
-        }
-        const svgImageInitialStateSignaturePattern = /static RNSVGImageState initialStateData\(ShadowNodeFragment const &fragment,\r?\n\s*ShadowNodeFamilyFragment const &familyFragment,\r?\n\s*ComponentDescriptor const &componentDescriptor\) \{/m;
-        if (svgImageInitialStateSignaturePattern.test(nextSvgImageShadowNodeContents)) {
-            nextSvgImageShadowNodeContents = nextSvgImageShadowNodeContents.replace(svgImageInitialStateSignaturePattern, 'static RNSVGImageState initialStateData(const Props::Shared& /*props*/,'
-                + `${svgImageShadowNodeNewline}`
-                + '                                            const ShadowNodeFamily::Shared& /*family*/,'
-                + `${svgImageShadowNodeNewline}`
-                + '                                            const ComponentDescriptor& /*componentDescriptor*/) {');
-        }
-        if (nextSvgImageShadowNodeContents !== svgImageShadowNodeContents) {
-            await fs_extra_1.default.writeFile(svgImageShadowNodePath, nextSvgImageShadowNodeContents);
-        }
-    }
-    if (!(await fs_extra_1.default.pathExists(svgPathComponentInstancePath))) {
-        return;
-    }
-    const svgPathComponentInstanceContents = await fs_extra_1.default.readFile(svgPathComponentInstancePath, 'utf8');
-    if (!svgPathComponentInstanceContents.includes('Float m_cacheScale;')) {
-        return;
-    }
-    await fs_extra_1.default.writeFile(svgPathComponentInstancePath, svgPathComponentInstanceContents.replace('Float m_cacheScale;', 'facebook::react::Float m_cacheScale;'));
-}
-function createGestureHandlerCompatibilityDescriptorHeader(componentName) {
-    return [
-        '#pragma once',
-        '',
-        '#include <react/renderer/components/view/ConcreteViewShadowNode.h>',
-        '#include <react/renderer/core/ConcreteComponentDescriptor.h>',
-        '',
-        'namespace facebook::react {',
-        '',
-        `inline constexpr char ${componentName}ComponentName[] = "${componentName}";`,
-        '',
-        `using ${componentName}ShadowNode = ConcreteViewShadowNode<${componentName}ComponentName>;`,
-        `using ${componentName}ComponentDescriptor = ConcreteComponentDescriptor<${componentName}ShadowNode>;`,
-        '',
-        '} // namespace facebook::react',
-        '',
-    ].join('\n');
-}
-function patchGestureHandlerCompatibilityPackageHeader(contents) {
-    if (contents.includes('createComponentDescriptorProviders() override;')) {
-        return contents;
-    }
-    return contents.replace('    std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;\n', [
-        '    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override;',
-        '',
-        '    ComponentJSIBinderByString createComponentJSIBinderByName() override;',
-        '',
-        '    std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;',
-    ].join('\n'));
-}
-function patchGestureHandlerCompatibilityPackageSource(contents) {
-    let nextContents = contents;
-    if (!nextContents.includes('#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"')) {
-        nextContents = nextContents.replace('#include "RNOH/RNInstanceCAPI.h"\n', '#include "RNOH/RNInstanceCAPI.h"\n#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"\n');
-    }
-    if (!nextContents.includes('#include "generated/RNGestureHandlerButtonComponentDescriptor.h"')) {
-        nextContents = nextContents.replace('#include "componentInstances/RNGestureHandlerRootViewComponentInstance.h"\n', '#include "componentInstances/RNGestureHandlerRootViewComponentInstance.h"\n#include "generated/RNGestureHandlerButtonComponentDescriptor.h"\n#include "generated/RNGestureHandlerRootViewComponentDescriptor.h"\n');
-    }
-    if (!nextContents.includes('class RNGestureHandlerComponentJSIBinder')) {
-        nextContents = nextContents.replace('using namespace rnoh;\nusing namespace facebook;\n\n', [
-            'using namespace rnoh;',
-            'using namespace facebook;',
-            '',
-            'class RNGestureHandlerComponentJSIBinder : public ViewComponentJSIBinder {',
-            'protected:',
-            '    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {',
-            '        auto nativeProps = ViewComponentJSIBinder::createNativeProps(rt);',
-            '        nativeProps.setProperty(rt, "exclusive", "boolean");',
-            '        nativeProps.setProperty(rt, "foreground", "boolean");',
-            '        nativeProps.setProperty(rt, "borderless", "boolean");',
-            '        nativeProps.setProperty(rt, "enabled", "boolean");',
-            '        nativeProps.setProperty(rt, "rippleColor", "Color");',
-            '        nativeProps.setProperty(rt, "rippleRadius", "number");',
-            '        nativeProps.setProperty(rt, "touchSoundDisabled", "boolean");',
-            '        return nativeProps;',
-            '    }',
-            '',
-            '    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {',
-            '        auto events = ViewComponentJSIBinder::createDirectEventTypes(rt);',
-            '        events.setProperty(rt, "onGestureHandlerEvent", createDirectEvent(rt, "onGestureHandlerEvent"));',
-            '        events.setProperty(',
-            '            rt,',
-            '            "onGestureHandlerStateChange",',
-            '            createDirectEvent(rt, "onGestureHandlerStateChange"));',
-            '        events.setProperty(rt, "topOnGestureHandlerEvent", createDirectEvent(rt, "onGestureHandlerEvent"));',
-            '        events.setProperty(',
-            '            rt,',
-            '            "topOnGestureHandlerStateChange",',
-            '            createDirectEvent(rt, "onGestureHandlerStateChange"));',
-            '        return events;',
-            '    }',
-            '};',
-            '',
-        ].join('\n'));
-    }
-    if (!nextContents.includes('RnohReactNativeHarmonyGestureHandlerPackage::createComponentDescriptorProviders()')) {
-        nextContents = nextContents.replace('EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers() {\n', [
-            'std::vector<facebook::react::ComponentDescriptorProvider>',
-            'RnohReactNativeHarmonyGestureHandlerPackage::createComponentDescriptorProviders() {',
-            '    return {',
-            '        facebook::react::concreteComponentDescriptorProvider<',
-            '            facebook::react::RNGestureHandlerButtonComponentDescriptor>(),',
-            '        facebook::react::concreteComponentDescriptorProvider<',
-            '            facebook::react::RNGestureHandlerRootViewComponentDescriptor>(),',
-            '    };',
-            '}',
-            '',
-            'ComponentJSIBinderByString',
-            'RnohReactNativeHarmonyGestureHandlerPackage::createComponentJSIBinderByName() {',
-            '    auto componentJSIBinder = std::make_shared<RNGestureHandlerComponentJSIBinder>();',
-            '    return {',
-            '        {"RNGestureHandlerButton", componentJSIBinder},',
-            '        {"RNGestureHandlerRootView", componentJSIBinder},',
-            '    };',
-            '}',
-            '',
-            'EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers() {',
-        ].join('\n'));
-    }
-    return nextContents;
-}
-function sanitizePackageName(packageName) {
-    return packageName.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
-}
-async function readNormalizedLocalHarPackageMetadata(directoryPath, packageName) {
-    await ensureNormalizedLocalHarModuleJson5(directoryPath);
-    const moduleJsonPaths = [
-        path_1.default.join(directoryPath, 'src', 'main', 'module.json5'),
-        path_1.default.join(directoryPath, 'src', 'main', 'module.json'),
-    ];
-    let moduleName = sanitizePackageName(packageName);
-    for (const moduleJsonPath of moduleJsonPaths) {
-        if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
-            continue;
-        }
-        try {
-            const parsed = json5_1.default.parse(await fs_extra_1.default.readFile(moduleJsonPath, 'utf8'));
-            if (typeof parsed?.module?.name === 'string' && parsed.module.name.trim().length > 0) {
-                moduleName = parsed.module.name.trim();
-                break;
-            }
-        }
-        catch {
-            // Ignore malformed module metadata and fall back to a sanitized package name.
-        }
-    }
-    return {
-        packageName,
-        moduleName,
-        directoryPath,
-    };
-}
-async function ensureNormalizedLocalHarModuleJson5(directoryPath) {
-    const moduleJson5Path = path_1.default.join(directoryPath, 'src', 'main', 'module.json5');
-    const moduleJsonPath = path_1.default.join(directoryPath, 'src', 'main', 'module.json');
-    const sourcePath = (await fs_extra_1.default.pathExists(moduleJsonPath))
-        ? moduleJsonPath
-        : ((await fs_extra_1.default.pathExists(moduleJson5Path)) ? moduleJson5Path : null);
-    if (!sourcePath) {
-        return;
-    }
-    const parsed = json5_1.default.parse(await fs_extra_1.default.readFile(sourcePath, 'utf8'));
-    const legacyModule = parsed.module && typeof parsed.module === 'object' && !Array.isArray(parsed.module)
-        ? parsed.module
-        : {};
-    const normalizedModule = {
-        name: typeof legacyModule.name === 'string' && legacyModule.name.trim().length > 0
-            ? legacyModule.name.trim()
-            : path_1.default.basename(directoryPath).replace(/[^a-zA-Z0-9]+/g, '_'),
-        type: typeof legacyModule.type === 'string' ? legacyModule.type : 'har',
-        deviceTypes: Array.isArray(legacyModule.deviceTypes) && legacyModule.deviceTypes.length > 0
-            ? legacyModule.deviceTypes
-            : ['default'],
-        installationFree: typeof legacyModule.installationFree === 'boolean' ? legacyModule.installationFree : false,
-    };
-    const passthroughKeys = [
-        'srcEntrance',
-        'srcEntry',
-        'description',
-        'process',
-        'mainElement',
-        'uiSyntax',
-        'metadata',
-        'abilities',
-        'extensionAbilities',
-        'requestPermissions',
-        'definePermissions',
-        'testRunner',
-        'dependencies',
-        'libIsolation',
-        'routerMap',
-        'appStartup',
-        'crossAppSharedConfig',
-    ];
-    for (const key of passthroughKeys) {
-        const value = legacyModule[key];
-        if (value !== undefined) {
-            normalizedModule[key] = value;
-        }
-    }
-    if (typeof legacyModule.virtualMachine === 'string') {
-        normalizedModule.virtualMachine = legacyModule.virtualMachine.includes('ark') ? 'ark' : 'default';
-    }
-    await fs_extra_1.default.writeFile(moduleJson5Path, JSON.stringify({
-        module: normalizedModule,
-    }, null, 2) + '\n');
-}
-async function ensureHarmonyBuildProfileSupportsNormalizedLocalDeps(harmonyProjectRoot, localHarPackages) {
-    if (localHarPackages.length === 0) {
-        return async () => { };
-    }
-    const buildProfilePath = path_1.default.join(harmonyProjectRoot, 'build-profile.json5');
-    if (!(await fs_extra_1.default.pathExists(buildProfilePath))) {
-        return async () => { };
-    }
-    const rawContents = await fs_extra_1.default.readFile(buildProfilePath, 'utf8');
-    const parsed = json5_1.default.parse(rawContents);
-    let didChange = false;
-    const products = Array.isArray(parsed.app?.products) ? parsed.app.products : [];
-    for (const product of products) {
-        let buildOption = product.buildOption;
-        if (!buildOption || typeof buildOption !== 'object' || Array.isArray(buildOption)) {
-            buildOption = {};
-            product.buildOption = buildOption;
-            didChange = true;
-        }
-        let strictMode = buildOption.strictMode;
-        if (!strictMode || typeof strictMode !== 'object' || Array.isArray(strictMode)) {
-            strictMode = {};
-            buildOption.strictMode = strictMode;
-            didChange = true;
-        }
-        if (strictMode.useNormalizedOHMUrl !== true) {
-            strictMode.useNormalizedOHMUrl = true;
-            didChange = true;
-        }
-    }
-    if (!Array.isArray(parsed.modules)) {
-        parsed.modules = [];
-        didChange = true;
-    }
-    for (const localHarPackage of localHarPackages) {
-        let relativeDirectory = path_1.default.relative(harmonyProjectRoot, localHarPackage.directoryPath);
-        relativeDirectory = relativeDirectory.split(path_1.default.sep).join('/');
-        if (!relativeDirectory.startsWith('.')) {
-            relativeDirectory = `./${relativeDirectory}`;
-        }
-        const existingModule = parsed.modules.find((moduleEntry) => {
-            return (moduleEntry?.srcPath === relativeDirectory ||
-                moduleEntry?.name === localHarPackage.moduleName);
-        });
-        if (existingModule) {
-            if (existingModule.srcPath !== relativeDirectory) {
-                existingModule.srcPath = relativeDirectory;
-                didChange = true;
-            }
-            continue;
-        }
-        parsed.modules.push({
-            name: localHarPackage.moduleName,
-            srcPath: relativeDirectory,
-        });
-        didChange = true;
-    }
-    if (!didChange) {
-        return async () => { };
-    }
-    await fs_extra_1.default.writeFile(buildProfilePath, JSON.stringify(parsed, null, 2) + '\n');
-    return async () => {
-        await fs_extra_1.default.writeFile(buildProfilePath, rawContents);
-    };
-}
-async function ensureRnohGeneratedTsShim(harmonyProjectRoot) {
-    const shimPath = path_1.default.join(harmonyProjectRoot, RNOH_GENERATED_TS_SHIM_RELATIVE_PATH);
-    let relativeTarget = path_1.default.relative(path_1.default.dirname(shimPath), path_1.default.join(harmonyProjectRoot, RNOH_NORMALIZED_TS_TARGET_RELATIVE_PATH));
-    relativeTarget = relativeTarget.replace(/\\/g, '/').replace(/\.ts$/, '');
-    if (!relativeTarget.startsWith('.')) {
-        relativeTarget = `./${relativeTarget}`;
-    }
-    await fs_extra_1.default.ensureDir(path_1.default.dirname(shimPath));
-    await fs_extra_1.default.writeFile(shimPath, `export * from '${relativeTarget}';\n`);
-}
-async function alignRnohCodegenWithNormalizedLocalPackage(harmonyProjectRoot, localHarPackages) {
-    const rnohPackage = localHarPackages.find((localPackage) => localPackage.packageName === '@rnoh/react-native-openharmony');
-    if (!rnohPackage) {
-        return async () => { };
-    }
-    const hvigorFilePath = path_1.default.join(harmonyProjectRoot, 'entry', 'hvigorfile.ts');
-    if (!(await fs_extra_1.default.pathExists(hvigorFilePath))) {
-        return async () => { };
-    }
-    const originalHvigorFile = await fs_extra_1.default.readFile(hvigorFilePath, 'utf8');
-    let relativeRnohModulePath = path_1.default.relative(harmonyProjectRoot, rnohPackage.directoryPath);
-    relativeRnohModulePath = relativeRnohModulePath.split(path_1.default.sep).join('/');
-    if (!relativeRnohModulePath.startsWith('.')) {
-        relativeRnohModulePath = `./${relativeRnohModulePath}`;
-    }
-    const updatedHvigorFile = originalHvigorFile.replace(/rnohModulePath:\s*['"][^'"]+['"]/, `rnohModulePath: '${relativeRnohModulePath}'`);
-    if (updatedHvigorFile !== originalHvigorFile) {
-        await fs_extra_1.default.writeFile(hvigorFilePath, updatedHvigorFile);
-    }
-    const generatedModuleRootPath = path_1.default.join(harmonyProjectRoot, RNOH_GENERATED_MODULE_ROOT_RELATIVE_PATH);
-    const backupRootPath = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'expo-harmony-rnoh-module-'));
-    const backupModuleRootPath = path_1.default.join(backupRootPath, 'react-native-openharmony');
-    let movedGeneratedModuleRoot = false;
-    if (await fs_extra_1.default.pathExists(generatedModuleRootPath)) {
-        await fs_extra_1.default.move(generatedModuleRootPath, backupModuleRootPath, { overwrite: true });
-        movedGeneratedModuleRoot = true;
-    }
-    return async () => {
-        if (updatedHvigorFile !== originalHvigorFile) {
-            await fs_extra_1.default.writeFile(hvigorFilePath, originalHvigorFile);
-        }
-        if (movedGeneratedModuleRoot) {
-            await fs_extra_1.default.remove(generatedModuleRootPath);
-            await fs_extra_1.default.ensureDir(path_1.default.dirname(generatedModuleRootPath));
-            await fs_extra_1.default.move(backupModuleRootPath, generatedModuleRootPath, { overwrite: true });
-        }
-        await fs_extra_1.default.remove(backupRootPath);
-    };
-}
-async function normalizeProjectRnohCliAutolinkingTemplates(projectRoot) {
-    const originalContentsByPath = new Map();
-    for (const relativePath of RNOH_CLI_AUTOLINKING_TEMPLATE_RELATIVE_PATHS) {
-        const targetPath = path_1.default.join(projectRoot, relativePath);
-        if (!(await fs_extra_1.default.pathExists(targetPath))) {
-            continue;
-        }
-        const currentContents = await fs_extra_1.default.readFile(targetPath, 'utf8');
-        const normalizedContents = normalizeRnohCliAutolinkingTemplateContents(currentContents);
-        if (normalizedContents === currentContents) {
-            continue;
-        }
-        originalContentsByPath.set(targetPath, currentContents);
-        await fs_extra_1.default.writeFile(targetPath, normalizedContents);
-    }
-    return async () => {
-        for (const [targetPath, originalContents] of originalContentsByPath.entries()) {
-            await fs_extra_1.default.writeFile(targetPath, originalContents);
-        }
-    };
-}
-function normalizeRnohCliAutolinkingTemplateContents(contents) {
-    return contents
-        .replace(/import type \{ RNPackageContext, RNOHPackage \} from '@rnoh\/react-native-openharmony';/g, "import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';")
-        .replace(/export function createRNOHPackages\(ctx: RNPackageContext\): RNOHPackage\[\] \{/g, 'export function createRNOHPackages(ctx: RNPackageContext): RNPackage[] {');
-}
-async function findHarmonyArtifacts(harmonyProjectRoot) {
-    const discoveredPaths = [];
-    await walkDirectory(harmonyProjectRoot, async (entryPath) => {
-        if (entryPath.endsWith('.hap') || entryPath.endsWith('.app') || entryPath.endsWith('.hsp')) {
-            discoveredPaths.push(entryPath);
-        }
-    });
-    return discoveredPaths.sort((left, right) => left.localeCompare(right));
-}
-async function walkDirectory(currentPath, visitor) {
-    if (!(await fs_extra_1.default.pathExists(currentPath))) {
-        return;
-    }
-    const entries = await fs_extra_1.default.readdir(currentPath, { withFileTypes: true });
-    for (const entry of entries) {
-        const nextPath = path_1.default.join(currentPath, entry.name);
-        if (entry.isDirectory()) {
-            await walkDirectory(nextPath, visitor);
-            continue;
-        }
-        await visitor(nextPath);
-    }
-}
-async function defaultCommandRunner(file, args, options) {
-    try {
-        const result = await execFileAsync(file, args, {
-            cwd: options.cwd,
-            env: options.env,
-            maxBuffer: 20 * 1024 * 1024,
-        });
-        return {
-            exitCode: 0,
-            stdout: result.stdout,
-            stderr: result.stderr,
-        };
-    }
-    catch (error) {
-        const failed = error;
-        return {
-            exitCode: typeof failed.code === 'number' ? failed.code : 1,
-            stdout: failed.stdout ?? '',
-            stderr: failed.stderr ?? failed.message ?? '',
-        };
-    }
-}
 function getDesiredHarmonyScripts(projectRoot) {
     return (0, project_1.loadProject)(projectRoot).then((loadedProject) => (0, template_1.buildDesiredPackageScripts)(loadedProject.packageJson));
 }