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

package/build/modules/modules.d.ts

@@ -0,0 +1,42 @@
+import { type BuildType, type Diagnostic, type ModuleDescriptor, type ModuleSource } from '@expo-harmony/expo-modules-autolinking';
+import type { ModulesAction } from './options';
+interface ModulesCommandOptions {
+    action: ModulesAction;
+    nativeModulesDir?: string;
+    packageName?: string;
+    variant?: BuildType;
+}
+interface ListedModule {
+    packageName: string;
+    packageVersion: string;
+    source: ModuleSource;
+    supportsHarmony: boolean;
+}
+interface ModulesListResult {
+    action: 'list';
+    duplicates: ReadonlyArray<{
+        packageName: string;
+        revisions: ReadonlyArray<{
+            path: string;
+            version: string;
+        }>;
+    }>;
+    missingIncludes: ReadonlyArray<string>;
+    modules: ReadonlyArray<ListedModule>;
+    ok: boolean;
+}
+interface ModulesInspectResult {
+    action: 'inspect';
+    modules: ReadonlyArray<ModuleDescriptor>;
+    ok: boolean;
+}
+interface ModulesVerifyResult {
+    action: 'verify';
+    diagnostics: ReadonlyArray<Diagnostic>;
+    modules: ReadonlyArray<ModuleDescriptor>;
+    ok: boolean;
+}
+export type ModulesCommandResult = ModulesInspectResult | ModulesListResult | ModulesVerifyResult;
+declare function runModulesCommandAsync(projectRoot: string, options: ModulesCommandOptions): Promise<ModulesCommandResult>;
+declare function formatModulesResult(result: ModulesCommandResult): string;
+export { formatModulesResult, runModulesCommandAsync };

package/build/modules/modules.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatModulesResult = formatModulesResult;
+exports.runModulesCommandAsync = runModulesCommandAsync;
+const expo_modules_autolinking_1 = require("@expo-harmony/expo-modules-autolinking");
+const errors_1 = require("../errors");
+function apiOptions(projectRoot, options) {
+    return {
+        projectRoot,
+        platform: 'harmony',
+        ...(options.nativeModulesDir === undefined ? {} : { nativeModulesDir: options.nativeModulesDir }),
+        ...(options.variant === undefined ? {} : { buildType: options.variant }),
+    };
+}
+async function runModulesCommandAsync(projectRoot, options) {
+    const shared = apiOptions(projectRoot, options);
+    if (options.action === 'list') {
+        const result = await (0, expo_modules_autolinking_1.searchModulesAsync)(shared);
+        return {
+            action: 'list',
+            duplicates: result.duplicates,
+            missingIncludes: result.missingIncludes,
+            modules: result.modules.map(module => ({
+                packageName: module.packageName,
+                packageVersion: module.packageVersion,
+                source: module.source,
+                supportsHarmony: module.supportsHarmony,
+            })),
+            ok: result.missingIncludes.length === 0,
+        };
+    }
+    if (options.action === 'inspect') {
+        const modules = await (0, expo_modules_autolinking_1.resolveModulesAsync)(shared);
+        const selected = options.packageName === undefined
+            ? modules
+            : modules.filter(module => module.packageName === options.packageName);
+        if (options.packageName !== undefined && selected.length === 0) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_MODULE_NOT_FOUND', `Harmony module '${options.packageName}' was not discovered. Run 'expo-harmony modules list' to inspect candidates.`, { operation: 'modules-inspect' });
+        }
+        return { action: 'inspect', modules: selected, ok: true };
+    }
+    const result = await (0, expo_modules_autolinking_1.verifyModulesAsync)(shared);
+    return {
+        action: 'verify',
+        diagnostics: result.diagnostics,
+        modules: result.modules,
+        ok: result.valid,
+    };
+}
+function formatDiagnostic(diagnostic) {
+    const subject = diagnostic.packageName ? ` ${diagnostic.packageName}` : '';
+    return `${diagnostic.severity === 'error' ? '✗' : '!'} [${diagnostic.code}]${subject}: ${diagnostic.message}`;
+}
+function formatModulesResult(result) {
+    if (result.action === 'list') {
+        const lines = result.modules.map(module => (`${module.supportsHarmony ? '✓' : '-'} ${module.packageName}@${module.packageVersion} [${module.source}]`));
+        for (const packageName of result.missingIncludes) {
+            lines.push(`✗ missing required package ${packageName}`);
+        }
+        for (const duplicate of result.duplicates) {
+            lines.push(`! duplicate ${duplicate.packageName}: ${duplicate.revisions.map(item => item.version).join(', ')}`);
+        }
+        return lines.length === 0 ? 'No native module candidates were discovered.' : lines.join('\n');
+    }
+    if (result.action === 'verify') {
+        if (result.diagnostics.length === 0) {
+            return `✓ Verified ${result.modules.length} Harmony native module(s).`;
+        }
+        return result.diagnostics.map(formatDiagnostic).join('\n');
+    }
+    return result.modules.map((module) => {
+        const arkTsModules = module.harmony.modules.join(', ') || 'none';
+        const har = module.arkTs
+            ? `${module.arkTs.ohPackageName} <- ${module.arkTs.harPath}`
+            : 'none';
+        return [
+            `${module.packageName}@${module.packageVersion}`,
+            `  source: ${module.source}`,
+            `  packageRoot: ${module.packageRoot}`,
+            `  ArkTS modules: ${arkTsModules}`,
+            `  HAR: ${har}`,
+        ].join('\n');
+    }).join('\n');
+}

package/build/modules/options.d.ts

@@ -0,0 +1,10 @@
+export type ModulesAction = 'inspect' | 'list' | 'verify';
+declare function parseModulesArgs(argv: string[]): {
+    action: ModulesAction;
+    help: boolean;
+    project: string;
+    packageName: string;
+    nativeModulesDir: string;
+    variant: "debug" | "release" | undefined;
+};
+export { parseModulesArgs };

package/build/modules/options.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModulesArgs = parseModulesArgs;
+const args_1 = require("../args");
+const errors_1 = require("../errors");
+const ModuleOptions = {
+    ...args_1.CommonOptions,
+    'package': { short: 'p', type: 'string' },
+    'variant': { type: 'string' },
+    'native-modules-dir': { type: 'string' },
+};
+function parseModulesArgs(argv) {
+    const { positionals, values } = (0, args_1.parseArgs)(ModuleOptions, argv);
+    const action = positionals[0];
+    if (values.help && action === undefined) {
+        return {
+            action: 'list',
+            help: true,
+            project: undefined,
+            packageName: values.package,
+            nativeModulesDir: values['native-modules-dir'],
+            variant: values.variant,
+        };
+    }
+    if (!action || !['inspect', 'list', 'verify'].includes(action)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', 'modules requires one of: list, inspect, verify.', { operation: 'parse-arguments' });
+    }
+    if (positionals.length > 2) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unexpected modules positional argument: ${positionals[2]}`, { operation: 'parse-arguments' });
+    }
+    if (values.variant !== undefined && !['debug', 'release'].includes(values.variant)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `--variant must be debug or release, received: ${values.variant}`, { operation: 'parse-arguments' });
+    }
+    if (values.package !== undefined && action !== 'inspect') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--package is supported by modules inspect only.', { operation: 'parse-arguments' });
+    }
+    return {
+        action,
+        help: Boolean(values.help),
+        project: positionals[1],
+        packageName: values.package,
+        nativeModulesDir: values['native-modules-dir'],
+        variant: values.variant,
+    };
+}

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,69 @@
+"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 config_1 = require("@expo/config");
+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;
+    const embedded = plan.buildMode === 'release' || (0, config_1.getConfig)(root).exp.updates?.useNativeDebug === true;
+    if (embedded) {
+        (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' } : {}),
+            ...(embedded ? { 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/native/cache.d.ts

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

package/build/native/cache.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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/internal/native-inputs");
+const errors_1 = require("../errors");
+const SchemaVersion = 1;
+async function readOptionalFile(file) {
+    try {
+        return await node_fs_1.default.promises.readFile(file);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return null;
+        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(root, plan) {
+    try {
+        return (0, native_inputs_1.fingerprintHarmonyNativeInputsSync)({
+            lockfile: plan.nativeInputs.lockfile,
+            manifest: plan.nativeInputs.manifest,
+            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(root, plan) {
+    const current = await resolveNativeDependencyFingerprintAsync(root, plan);
+    const file = plan.nativeCache.stateFile;
+    const source = await readOptionalFile(file);
+    let saved = null;
+    if (source) {
+        try {
+            saved = JSON.parse(source.toString('utf8'));
+        }
+        catch {
+            saved = null;
+        }
+    }
+    const changed = saved?.schemaVersion !== SchemaVersion
+        || saved?.fingerprintVersion !== native_inputs_1.HarmonyNativeInputsFingerprintVersion
+        || saved?.fingerprint !== current.fingerprint;
+    if (changed) {
+        for (const root of plan.nativeCache.invalidationRoots) {
+            await node_fs_1.default.promises.rm(root, { force: true, recursive: true });
+        }
+    }
+    return {
+        ...current,
+        cacheFile: file,
+        changed,
+    };
+}
+async function commitHarmonyNativeBuildCacheAsync(state) {
+    const root = node_path_1.default.dirname(state.cacheFile);
+    const temp = `${state.cacheFile}.${process.pid}.tmp`;
+    await node_fs_1.default.promises.mkdir(root, { recursive: true });
+    await node_fs_1.default.promises.writeFile(temp, `${JSON.stringify({
+        artifactCount: state.artifactCount,
+        fingerprint: state.fingerprint,
+        fingerprintVersion: state.fingerprintVersion,
+        schemaVersion: SchemaVersion,
+    }, null, 2)}\n`);
+    await node_fs_1.default.promises.rename(temp, state.cacheFile);
+}

package/build/native/hvigor.d.ts

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

package/build/native/hvigor.js

@@ -0,0 +1,83 @@
+"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;
+exports.publishHarmonyNativeRuntime = publishHarmonyNativeRuntime;
+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);
+    }
+    publishHarmonyNativeRuntime(root, mode);
+    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);
+}
+function publishHarmonyNativeRuntime(root, mode) {
+    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'), 'runtime', root, '--publish', '--variant', mode], 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 };