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

package/build/index.js

@@ -7,15 +7,16 @@ var build_1 = require("./buildHap/build");
 Object.defineProperty(exports, "buildHarmonyAsync", { enumerable: true, get: function () { return build_1.buildHarmonyAsync; } });
 var export_1 = require("./exportEmbed/export");
 Object.defineProperty(exports, "exportEmbedAsync", { enumerable: true, get: function () { return export_1.exportEmbedAsync; } });
-var tools_1 = require("./tools");
-Object.defineProperty(exports, "resolveHarmonyBuildPlanAsync", { enumerable: true, get: function () { return tools_1.resolveHarmonyBuildPlanAsync; } });
-Object.defineProperty(exports, "resolveHarmonyToolchain", { enumerable: true, get: function () { return tools_1.resolveHarmonyToolchain; } });
-var install_1 = require("./run/install");
+var project_1 = require("./native/project");
+Object.defineProperty(exports, "resolveHarmonyBuildPlanAsync", { enumerable: true, get: function () { return project_1.resolveHarmonyBuildPlanAsync; } });
+var toolchain_1 = require("./native/toolchain");
+Object.defineProperty(exports, "resolveHarmonyToolchain", { enumerable: true, get: function () { return toolchain_1.resolveHarmonyToolchain; } });
+var install_1 = require("./native/install");
 Object.defineProperty(exports, "installHarmonyDependenciesAsync", { enumerable: true, get: function () { return install_1.installHarmonyDependenciesAsync; } });
 var modules_1 = require("./modules/modules");
 Object.defineProperty(exports, "formatModulesResult", { enumerable: true, get: function () { return modules_1.formatModulesResult; } });
 Object.defineProperty(exports, "runModulesCommandAsync", { enumerable: true, get: function () { return modules_1.runModulesCommandAsync; } });
-var cache_1 = require("./run/cache");
+var cache_1 = require("./native/cache");
 Object.defineProperty(exports, "commitHarmonyNativeBuildCacheAsync", { enumerable: true, get: function () { return cache_1.commitHarmonyNativeBuildCacheAsync; } });
 Object.defineProperty(exports, "prepareHarmonyNativeBuildCacheAsync", { enumerable: true, get: function () { return cache_1.prepareHarmonyNativeBuildCacheAsync; } });
 var run_1 = require("./run/run");

package/build/internal/prebuild.d.ts

@@ -0,0 +1,3 @@
+export { withGeneratedProjectAsync } from '../prebuild/check';
+export { assertSafeCleanTarget } from '../prebuild/clean';
+export { withHarmonyProjectLockAsync } from '../projectLock';

package/build/internal/prebuild.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withHarmonyProjectLockAsync = exports.assertSafeCleanTarget = exports.withGeneratedProjectAsync = void 0;
+var check_1 = require("../prebuild/check");
+Object.defineProperty(exports, "withGeneratedProjectAsync", { enumerable: true, get: function () { return check_1.withGeneratedProjectAsync; } });
+var clean_1 = require("../prebuild/clean");
+Object.defineProperty(exports, "assertSafeCleanTarget", { enumerable: true, get: function () { return clean_1.assertSafeCleanTarget; } });
+var projectLock_1 = require("../projectLock");
+Object.defineProperty(exports, "withHarmonyProjectLockAsync", { enumerable: true, get: function () { return projectLock_1.withHarmonyProjectLockAsync; } });

package/build/log.d.ts

@@ -0,0 +1,4 @@
+export type Log = Pick<Console, 'error' | 'log' | 'warn'>;
+export declare function progress(options: {
+    io?: Log;
+}, message: string): void;

package/build/log.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progress = progress;
+function progress(options, message) {
+    options.io?.log(`› ${message}`);
+}

package/build/modules/index.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from '../command';
+export declare const command: Command;

package/build/modules/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const options_1 = require("./options");
+const command = async (argv, io) => {
+    const args = (0, command_1.parseCommandArgs)(options_1.parseModulesArgs, argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    const { formatModulesResult, runModulesCommandAsync } = await import('./modules.js');
+    const result = await runModulesCommandAsync(root, options);
+    io.log(formatModulesResult(result));
+    return result.ok ? 0 : 1;
+};
+exports.command = command;

package/build/native/bare.d.ts

@@ -0,0 +1,4 @@
+import type { BareHarmonyBuildPlan } from './types';
+declare function isBareHarmonyProject(root: string): boolean;
+declare function resolveBareHarmonyBuildPlan(root: string, mode: 'debug' | 'release'): BareHarmonyBuildPlan;
+export { isBareHarmonyProject, resolveBareHarmonyBuildPlan };

package/build/native/bare.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBareHarmonyProject = isBareHarmonyProject;
+exports.resolveBareHarmonyBuildPlan = resolveBareHarmonyBuildPlan;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const json5_1 = __importDefault(require("json5"));
+const errors_1 = require("../errors");
+function isBareHarmonyProject(root) {
+    return node_fs_1.default.existsSync(node_path_1.default.join(root, 'harmony'))
+        && !node_fs_1.default.existsSync(node_path_1.default.join(root, 'harmony/.expo-harmony-template'))
+        && !node_fs_1.default.existsSync(node_path_1.default.join(root, '.expo/harmony/cng-manifest.json'));
+}
+function record(value, field) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Native ${field} must be an object.`, { operation: 'resolve-build' });
+    }
+    return value;
+}
+function records(value, field) {
+    if (!Array.isArray(value)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Native ${field} must be an array.`, { operation: 'resolve-build' });
+    }
+    return value.map(item => record(item, field));
+}
+function readJson(file) {
+    try {
+        return record(json5_1.default.parse(node_fs_1.default.readFileSync(file, 'utf8')), file);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Cannot read native project file ${file}: ${cause.message}`, { cause, operation: 'resolve-build' });
+    }
+}
+function identifier(value, field) {
+    if (typeof value !== 'string' || !/^[A-Za-z_][A-Za-z0-9_.]*$/.test(value)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `The native project must specify a valid ${field}.`, { operation: 'resolve-build' });
+    }
+    return value;
+}
+function selectDefault(items, field) {
+    if (items.length === 0) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `No ${field} is defined in harmony/build-profile.json5.`, { operation: 'resolve-build' });
+    }
+    const defaults = items.filter(item => item.name === 'default');
+    if (defaults.length === 1)
+        return defaults[0];
+    if (items.length === 1)
+        return items[0];
+    throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Multiple ${field} are defined; name the intended default "default" in harmony/build-profile.json5.`, { operation: 'resolve-build' });
+}
+function resolveBareHarmonyBuildPlan(root, mode) {
+    const harmony = node_path_1.default.join(root, 'harmony');
+    const entry = node_path_1.default.join(harmony, 'entry');
+    for (const directory of [harmony, entry]) {
+        if (!node_fs_1.default.existsSync(directory)
+            || !node_fs_1.default.lstatSync(directory).isDirectory() || node_fs_1.default.lstatSync(directory).isSymbolicLink()) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Bare Harmony projects require a regular directory at ${directory}.`, { operation: 'resolve-build' });
+        }
+    }
+    const profile = readJson(node_path_1.default.join(harmony, 'build-profile.json5'));
+    const app = record(readJson(node_path_1.default.join(harmony, 'AppScope/app.json5')).app, 'app');
+    const module = record(readJson(node_path_1.default.join(entry, 'src/main/module.json5')).module, 'module');
+    const name = identifier(module.name, 'module.name');
+    const registration = records(profile.modules, 'modules').find(item => item.name === name);
+    if (!registration || typeof registration.srcPath !== 'string'
+        || node_path_1.default.resolve(harmony, registration.srcPath) !== entry || module.type !== 'entry') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', 'Bare Harmony autolinking requires an entry module at harmony/entry, registered in build-profile.json5.', { operation: 'resolve-build' });
+    }
+    const config = record(profile.app, 'build-profile.app');
+    const selected = selectDefault(records(config.products, 'products'), 'products');
+    const product = identifier(selected.name, 'product name');
+    const targets = records(registration.targets, 'module targets').filter((item) => {
+        if (item.applyToProducts === undefined)
+            return true;
+        if (!Array.isArray(item.applyToProducts) || item.applyToProducts.some(value => typeof value !== 'string')) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', 'Native target.applyToProducts must be an array of product names.', { operation: 'resolve-build' });
+        }
+        return item.applyToProducts.includes(product);
+    });
+    const target = identifier(selectDefault(targets, 'module targets').name, 'target name');
+    const ability = identifier(module.mainElement, 'module.mainElement');
+    if (!records(module.abilities, 'abilities').some(item => item.name === ability)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Ability ${ability} is missing from module.json5.`, { operation: 'resolve-build' });
+    }
+    const bundle = identifier(app.bundleName, 'app.bundleName');
+    const signed = Boolean(selected.signingConfig);
+    if (signed && !records(config.signingConfigs, 'signingConfigs').some(item => item.name === selected.signingConfig)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_PROJECT', `Signing config ${selected.signingConfig} is referenced by the product but is not defined.`, { operation: 'resolve-build' });
+    }
+    const rawfile = node_path_1.default.join(entry, 'src/main/resources/rawfile');
+    const metadata = node_path_1.default.join(root, '.expo/harmony/export');
+    return {
+        workflow: 'bare',
+        abilityName: ability,
+        buildMode: mode,
+        bundleName: bundle,
+        harmonyRoot: harmony,
+        moduleName: name,
+        moduleRoot: entry,
+        productName: product,
+        targetName: target,
+        expectedHap: node_path_1.default.join(entry, `build/${target}/outputs/${target}/${name}-${target}-${signed ? 'signed' : 'unsigned'}.hap`),
+        hvigorArgs: ['--mode', 'module', '-p', `module=${name}@${target}`, '-p', `product=${product}`, '-p', `buildMode=${mode}`, '--no-daemon', 'assembleHap'],
+        exportPaths: {
+            bundle: node_path_1.default.join(rawfile, 'hermes_bundle.hbc'),
+            manifest: node_path_1.default.join(root, '.expo/harmony/export-manifest.json'),
+            metadataRoot: metadata,
+            rawfileRoot: rawfile,
+            sourceMap: node_path_1.default.join(metadata, 'hermes_bundle.hbc.map'),
+        },
+        nativeCache: {
+            invalidationRoots: [node_path_1.default.join(entry, '.cxx'), node_path_1.default.join(entry, 'build')],
+            stateFile: node_path_1.default.join(entry, '.cxx/.expo-harmony-native-dependencies.json'),
+        },
+        nativeInputs: {
+            lockfile: node_path_1.default.join(harmony, 'oh-package-lock.json5'),
+            manifest: node_path_1.default.join(harmony, 'oh-package.json5'),
+        },
+        projectFiles: {
+            hvigorConfig: node_path_1.default.join(harmony, 'hvigor/hvigor-config.json5'),
+            moduleHvigor: node_path_1.default.join(entry, 'hvigorfile.ts'),
+            moduleJson: node_path_1.default.join(entry, 'src/main/module.json5'),
+            projectBuildProfile: node_path_1.default.join(harmony, 'build-profile.json5'),
+            rootHvigor: node_path_1.default.join(harmony, 'hvigorfile.ts'),
+        },
+    };
+}

package/build/native/build.d.ts

@@ -0,0 +1,15 @@
+import type { HarmonyToolchain } from './toolchain';
+import type { HarmonyBuildPlan } from './types';
+import { type Log } from '../log';
+export interface NativeBuildResult {
+    export: null | {
+        assetCount: number;
+        bundleSha256: string;
+        sourceMapSha256: string;
+    };
+    hapPath: string;
+}
+export declare function buildNativeAsync(root: string, plan: HarmonyBuildPlan, tools: HarmonyToolchain, options: {
+    io?: Log;
+    resetCache?: boolean;
+}, steps: Record<string, number>): Promise<NativeBuildResult>;

package/build/native/build.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNativeAsync = buildNativeAsync;
+const node_path_1 = __importDefault(require("node:path"));
+const cache_1 = require("./cache");
+const install_1 = require("./install");
+const errors_1 = require("../errors");
+const export_1 = require("../exportEmbed/export");
+const file_1 = require("../file");
+const log_1 = require("../log");
+const path_1 = require("../path");
+const process_1 = require("../process");
+const profile_1 = require("../profile");
+async function buildNativeAsync(root, plan, tools, options, steps) {
+    let exported = null;
+    if (plan.buildMode === 'release') {
+        (0, log_1.progress)(options, 'Exporting the release Hermes bundle');
+        const manifest = await (0, profile_1.timedAsync)(steps, 'export', () => (0, export_1.exportEmbedAsync)(root, {
+            resetCache: options.resetCache,
+            skipDoctor: true,
+        }));
+        exported = {
+            assetCount: manifest.assets.length,
+            bundleSha256: manifest.bundle.sha256,
+            sourceMapSha256: manifest.sourceMap.sha256,
+        };
+    }
+    else {
+        steps.export = 0;
+    }
+    (0, log_1.progress)(options, 'Installing Harmony project dependencies');
+    await (0, profile_1.timedAsync)(steps, 'ohpm', () => (0, install_1.installHarmonyDependenciesAsync)(plan, tools));
+    (0, log_1.progress)(options, 'Checking Harmony native dependency cache');
+    const cache = await (0, profile_1.timedAsync)(steps, 'nativeCache', () => (0, cache_1.prepareHarmonyNativeBuildCacheAsync)(root, plan));
+    if (cache.changed)
+        (0, log_1.progress)(options, 'Invalidated stale Harmony native build objects');
+    (0, log_1.progress)(options, `Building the ${plan.buildMode} HAP`);
+    await (0, profile_1.timedAsync)(steps, 'build', () => (0, process_1.runCheckedAsync)(tools.hvigor.command, [
+        ...tools.hvigor.args,
+        ...plan.hvigorArgs,
+    ], {
+        code: 'ERR_HARMONY_BUILD_FAILED',
+        cwd: plan.harmonyRoot,
+        env: {
+            ...process.env,
+            EXPO_HARMONY_NODE: process.env.EXPO_HARMONY_NODE || process.execPath,
+            EXPO_METRO_TARGET: 'harmony',
+            HERMES_V1_ENABLED: 'true',
+            ...(plan.workflow === 'bare' ? { EXPO_HARMONY_NATIVE_PREPARED: '1' } : {}),
+            ...(plan.buildMode === 'release' ? { EXPO_HARMONY_BUNDLE_PREBUILT: '1' } : {}),
+            ...(tools.sdkHome && !process.env.DEVECO_SDK_HOME
+                ? { DEVECO_SDK_HOME: tools.sdkHome }
+                : {}),
+        },
+        message: 'Hvigor build',
+        operation: 'hvigor-build',
+        timeoutMs: 15 * 60_000,
+    }));
+    if (!(0, file_1.isNonEmptyRegularFile)(plan.expectedHap)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_HAP_MISSING', 'Hvigor completed without producing the expected non-empty regular HAP.', { operation: 'verify-hap' });
+    }
+    await (0, profile_1.timedAsync)(steps, 'nativeCacheCommit', () => (0, cache_1.commitHarmonyNativeBuildCacheAsync)(cache));
+    return { export: exported, hapPath: (0, path_1.toPosixPath)(node_path_1.default.relative(root, plan.expectedHap)) };
+}

package/build/{run → native}/cache.d.ts

@@ -1,4 +1,4 @@
-import type { HarmonyBuildPlan } from '../tools';
+import { type HarmonyBuildPlan } from './types';
 export interface HarmonyNativeBuildCacheState {
     artifactCount: number;
     cacheFile: string;
@@ -6,6 +6,6 @@ export interface HarmonyNativeBuildCacheState {
     fingerprint: string;
     fingerprintVersion: number;
 }
-declare function prepareHarmonyNativeBuildCacheAsync(projectRoot: string, plan: HarmonyBuildPlan): Promise<HarmonyNativeBuildCacheState>;
+declare function prepareHarmonyNativeBuildCacheAsync(root: string, plan: HarmonyBuildPlan): Promise<HarmonyNativeBuildCacheState>;
 declare function commitHarmonyNativeBuildCacheAsync(state: HarmonyNativeBuildCacheState): Promise<void>;
 export { commitHarmonyNativeBuildCacheAsync, prepareHarmonyNativeBuildCacheAsync, };

package/build/{run → native}/cache.js

@@ -7,9 +7,9 @@ exports.commitHarmonyNativeBuildCacheAsync = commitHarmonyNativeBuildCacheAsync;
 exports.prepareHarmonyNativeBuildCacheAsync = prepareHarmonyNativeBuildCacheAsync;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const native_inputs_1 = require("@expo-harmony/config-plugins/native-inputs");
+const native_inputs_1 = require("@expo-harmony/config-plugins/internal/native-inputs");
 const errors_1 = require("../errors");
-const CacheSchemaVersion = 1;
+const SchemaVersion = 1;
 async function readOptionalFile(file) {
     try {
         return await node_fs_1.default.promises.readFile(file);
@@ -20,20 +20,20 @@ async function readOptionalFile(file) {
         throw new errors_1.HarmonyCliError(error.code || 'ERR_HARMONY_NATIVE_CACHE', error.message || `Cannot read a Harmony native cache input: ${file}`, { cause: error, exitCode: error.exitCode, operation: error.operation });
     }
 }
-async function resolveNativeDependencyFingerprintAsync(projectRoot, plan) {
+async function resolveNativeDependencyFingerprintAsync(root, plan) {
     try {
         return (0, native_inputs_1.fingerprintHarmonyNativeInputsSync)({
             lockfile: plan.nativeInputs.lockfile,
             manifest: plan.nativeInputs.manifest,
-            projectRoot,
+            projectRoot: root,
         });
     }
     catch (cause) {
         throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_CACHE', `Cannot fingerprint generated Harmony native dependencies: ${cause.message}`, { cause, operation: 'native-cache' });
     }
 }
-async function prepareHarmonyNativeBuildCacheAsync(projectRoot, plan) {
-    const current = await resolveNativeDependencyFingerprintAsync(projectRoot, plan);
+async function prepareHarmonyNativeBuildCacheAsync(root, plan) {
+    const current = await resolveNativeDependencyFingerprintAsync(root, plan);
     const file = plan.nativeCache.stateFile;
     const source = await readOptionalFile(file);
     let saved = null;
@@ -45,7 +45,7 @@ async function prepareHarmonyNativeBuildCacheAsync(projectRoot, plan) {
             saved = null;
         }
     }
-    const changed = saved?.schemaVersion !== CacheSchemaVersion
+    const changed = saved?.schemaVersion !== SchemaVersion
         || saved?.fingerprintVersion !== native_inputs_1.HarmonyNativeInputsFingerprintVersion
         || saved?.fingerprint !== current.fingerprint;
     if (changed) {
@@ -67,7 +67,7 @@ async function commitHarmonyNativeBuildCacheAsync(state) {
         artifactCount: state.artifactCount,
         fingerprint: state.fingerprint,
         fingerprintVersion: state.fingerprintVersion,
-        schemaVersion: CacheSchemaVersion,
+        schemaVersion: SchemaVersion,
     }, null, 2)}\n`);
     await node_fs_1.default.promises.rename(temp, state.cacheFile);
 }

package/build/native/hvigor.d.ts

@@ -0,0 +1,2 @@
+export declare function prepareHarmonyNativeBuild(root: string, mode: 'debug' | 'release'): void;
+export declare function bundleHarmonyNativeBuild(root: string): void;

package/build/native/hvigor.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareHarmonyNativeBuild = prepareHarmonyNativeBuild;
+exports.bundleHarmonyNativeBuild = bundleHarmonyNativeBuild;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const native_inputs_1 = require("@expo-harmony/config-plugins/internal/native-inputs");
+const errors_1 = require("../errors");
+const toolchain_1 = require("./toolchain");
+function nodeExecutable() {
+    const candidates = process.env.EXPO_HARMONY_NODE
+        ? [process.env.EXPO_HARMONY_NODE]
+        : [
+            process.execPath,
+            ...(process.env.PATH || '').split(node_path_1.default.delimiter).filter(Boolean)
+                .map(directory => node_path_1.default.join(directory, process.platform === 'win32' ? 'node.exe' : 'node')),
+        ];
+    for (const candidate of new Set(candidates)) {
+        const result = (0, node_child_process_1.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 errors_1.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, args, cwd) {
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        cwd,
+        env: { ...(0, toolchain_1.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 errors_1.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.
+function prepareHarmonyNativeBuild(root, mode) {
+    const harmony = node_path_1.default.join(root, 'harmony');
+    if (process.env.EXPO_HARMONY_NATIVE_PREPARED !== '1') {
+        const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+        const manifest = node_path_1.default.resolve(node_path_1.default.dirname(require.resolve('@expo-harmony/expo-modules-autolinking')), '../package.json');
+        const bin = node_path_1.default.resolve(node_path_1.default.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 } = (0, toolchain_1.resolveHarmonyToolchain)();
+        run(ohpm.command, [...ohpm.args, 'install', '--all'], harmony);
+    }
+    const { fingerprint } = (0, native_inputs_1.fingerprintHarmonyNativeInputsSync)({
+        projectRoot: root,
+        manifest: node_path_1.default.join(harmony, 'oh-package.json5'),
+        lockfile: node_path_1.default.join(harmony, 'oh-package-lock.json5'),
+    });
+    const file = node_path_1.default.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 (node_fs_1.default.existsSync(file) && node_fs_1.default.readFileSync(file, 'utf8') === content)
+        return;
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+    const temp = `${file}.${node_crypto_1.default.randomUUID()}.tmp`;
+    try {
+        node_fs_1.default.writeFileSync(temp, content);
+        node_fs_1.default.renameSync(temp, file);
+    }
+    finally {
+        node_fs_1.default.rmSync(temp, { force: true });
+    }
+}
+function bundleHarmonyNativeBuild(root) {
+    if (process.env.EXPO_HARMONY_BUNDLE_PREBUILT === '1')
+        return;
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    run(nodeExecutable(), [require.resolve('@expo-harmony/cli/bin/expo-harmony'), 'export:embed', root], root);
+}

package/build/native/install.d.ts

@@ -0,0 +1,5 @@
+import type { HarmonyBuildPlan } from './types';
+import type { HarmonyToolchain } from './toolchain';
+export declare function installHarmonyDependenciesAsync(plan: Pick<HarmonyBuildPlan, 'harmonyRoot'>, tools: HarmonyToolchain, options?: {
+    timeoutMs?: number;
+}): Promise<void>;

package/build/native/install.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installHarmonyDependenciesAsync = installHarmonyDependenciesAsync;
+const process_1 = require("../process");
+async function installHarmonyDependenciesAsync(plan, tools, options = {}) {
+    await (0, process_1.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/build/native/prepareProject.d.ts

@@ -0,0 +1,11 @@
+import { type Log } from '../log';
+import type { HarmonyBuildPlan } from './types';
+interface PrepareProjectOptions {
+    io?: Log;
+    requireDeviceTools?: boolean;
+    check?: boolean;
+    sync: boolean;
+    variant: 'debug' | 'release';
+}
+declare function prepareNativeProjectAsync(root: string, options: PrepareProjectOptions, steps: Record<string, number>): Promise<HarmonyBuildPlan>;
+export { prepareNativeProjectAsync };

package/build/native/prepareProject.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareNativeProjectAsync = prepareNativeProjectAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const expo_modules_autolinking_1 = require("@expo-harmony/expo-modules-autolinking");
+const doctor_1 = require("../doctor/doctor");
+const errors_1 = require("../errors");
+const log_1 = require("../log");
+const profile_1 = require("../profile");
+const check_1 = require("../prebuild/check");
+const prebuild_1 = require("../prebuild/prebuild");
+const toolchain_1 = require("./toolchain");
+const project_1 = require("./project");
+async function prepareNativeProjectAsync(root, options, steps) {
+    const plan = await (0, profile_1.timedAsync)(steps, 'buildPlan', () => (0, project_1.resolveHarmonyBuildPlanIfPresentAsync)(root, {
+        buildMode: options.variant,
+    }));
+    const exists = Boolean(plan && node_fs_1.default.existsSync(plan.harmonyRoot));
+    if (plan?.workflow === 'bare' && options.sync) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_BARE_SYNC', '--sync regenerates CNG projects and cannot be used with a manually maintained bare project.', { operation: 'build' });
+    }
+    (0, log_1.progress)(options, 'Checking the Harmony project');
+    const doctor = await (0, profile_1.timedAsync)(steps, 'doctor', () => (0, doctor_1.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 errors_1.HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', `Harmony doctor found blocking checks: ${checks.join(', ') || 'unknown'}.`, { operation: 'doctor' });
+    }
+    if (plan?.workflow === 'bare') {
+        (0, log_1.progress)(options, 'Autolinking the bare Harmony project');
+        await (0, profile_1.timedAsync)(steps, 'autolinking', () => (0, expo_modules_autolinking_1.linkModulesAsync)({
+            projectRoot: root,
+            harmonyProjectPath: plan.harmonyRoot,
+            buildType: options.variant,
+            env: (0, toolchain_1.createHarmonyToolchainEnv)(),
+        }));
+        steps.prebuild = 0;
+        steps.cngCheck = 0;
+        return plan;
+    }
+    if (!exists || options.sync) {
+        (0, log_1.progress)(options, exists
+            ? 'Synchronizing the generated Harmony project'
+            : 'Generating the missing Harmony project');
+        await (0, profile_1.timedAsync)(steps, 'prebuild', () => (0, prebuild_1.prebuildParsedAsync)(root, [], { buildType: options.variant }));
+        steps.cngCheck = 0;
+        return (0, profile_1.timedAsync)(steps, 'buildPlan', () => (0, project_1.resolveHarmonyBuildPlanAsync)(root, { buildMode: options.variant }));
+    }
+    steps.prebuild = 0;
+    if (options.check === false) {
+        steps.cngCheck = 0;
+        return plan;
+    }
+    (0, log_1.progress)(options, 'Checking CNG ownership and drift');
+    const check = await (0, profile_1.timedAsync)(steps, 'cngCheck', () => (0, check_1.checkAsync)(root, { buildType: options.variant }));
+    if (!check.clean) {
+        const summary = check.changes.slice(0, 8).map(change => `${change.type}:${change.path}`).join(', ');
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_DRIFT', `Generated Harmony files differ from CNG desired state${summary ? ` (${summary})` : ''}. Run expo-harmony prebuild or retry with --sync.`, { operation: 'check' });
+    }
+    return plan;
+}

package/build/native/project.d.ts

@@ -0,0 +1,8 @@
+import type { HarmonyBuildPlan } from './types';
+declare function resolveHarmonyBuildPlanIfPresentAsync(root: string, options?: {
+    buildMode?: 'debug' | 'release';
+}): Promise<HarmonyBuildPlan | null>;
+declare function resolveHarmonyBuildPlanAsync(root: string, options?: {
+    buildMode?: 'debug' | 'release';
+}): Promise<HarmonyBuildPlan>;
+export { resolveHarmonyBuildPlanAsync, resolveHarmonyBuildPlanIfPresentAsync };

package/build/native/project.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHarmonyBuildPlanAsync = resolveHarmonyBuildPlanAsync;
+exports.resolveHarmonyBuildPlanIfPresentAsync = resolveHarmonyBuildPlanIfPresentAsync;
+const internal_1 = require("@expo-harmony/prebuild-config/internal");
+const errors_1 = require("../errors");
+const bare_1 = require("./bare");
+function createHarmonyBuildPlan(root, build, mode) {
+    const resolve = relative => (0, internal_1.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)])),
+        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)])),
+        targetName: build.identity.targetName,
+    };
+}
+async function resolveHarmonyBuildPlanIfPresentAsync(root, options = {}) {
+    const mode = options.buildMode || 'debug';
+    if (!['debug', 'release'].includes(mode)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Harmony buildMode must be debug or release, received: ${mode}`, { operation: 'resolve-build' });
+    }
+    let manifest;
+    try {
+        manifest = await (0, internal_1.readManifestIfPresentAsync)(root);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError(cause.code || 'ERR_HARMONY_TEMPLATE_INVALID', `Cannot read the generated Harmony build descriptor: ${cause.message}`, { cause, operation: 'resolve-build' });
+    }
+    if (!manifest) {
+        return (0, bare_1.isBareHarmonyProject)(root) ? (0, bare_1.resolveBareHarmonyBuildPlan)(root, mode) : null;
+    }
+    return createHarmonyBuildPlan(root, manifest.build, mode);
+}
+async function resolveHarmonyBuildPlanAsync(root, options = {}) {
+    const plan = await resolveHarmonyBuildPlanIfPresentAsync(root, options);
+    if (!plan) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_DRIFT', 'Cannot read the generated Harmony build descriptor because the CNG manifest is missing.', { operation: 'resolve-build' });
+    }
+    return plan;
+}

package/build/native/toolchain.d.ts

@@ -0,0 +1,16 @@
+export interface HarmonyTool {
+    args: string[];
+    command: string;
+    source: 'deveco' | 'override' | 'path';
+}
+export interface HarmonyToolchain {
+    hdc: HarmonyTool;
+    hvigor: HarmonyTool;
+    ohpm: HarmonyTool;
+    sdkHome: string | null;
+    toolsRoot: string | null;
+}
+declare function resolveHarmonyToolchain(): HarmonyToolchain;
+declare function createHarmonyToolchainEnv(toolchain?: HarmonyToolchain): NodeJS.ProcessEnv;
+declare function resolveHarmonyEmulator(toolchain: HarmonyToolchain): HarmonyTool;
+export { createHarmonyToolchainEnv, resolveHarmonyEmulator, resolveHarmonyToolchain };