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

package/build/doctor/doctor.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorAsync = doctorAsync;
+exports.formatDoctor = formatDoctor;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("@expo/config");
+const config_plugins_1 = require("@expo-harmony/config-plugins");
+const expo_modules_autolinking_1 = require("@expo-harmony/expo-modules-autolinking");
+const native_project_1 = require("@expo-harmony/prebuild-config/native-project");
+const signing_1 = require("@expo-harmony/prebuild-config/signing");
+const process_1 = require("../process");
+const projectLock_1 = require("../projectLock");
+const tools_1 = require("../tools");
+const upstream_1 = require("../upstream");
+function hasPlugin(plugins, packageName) {
+    return (plugins || []).some(plugin => (Array.isArray(plugin) ? plugin[0] : plugin) === packageName);
+}
+function check(id, status, message, details) {
+    return { id, status, message, ...(details ? { details } : {}) };
+}
+function canResolvePackage(projectRoot, packageName) {
+    const projectRequire = (0, node_module_1.createRequire)(node_path_1.default.join(projectRoot, 'package.json'));
+    try {
+        projectRequire.resolve(`${packageName}/package.json`);
+        return true;
+    }
+    catch {
+        try {
+            projectRequire.resolve(packageName);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+async function validateMetroConfigAsync(projectRoot) {
+    const projectRequire = (0, node_module_1.createRequire)(node_path_1.default.join(projectRoot, 'package.json'));
+    let metroConfig;
+    try {
+        metroConfig = projectRequire('metro-config');
+    }
+    catch (cause) {
+        throw new Error('Cannot load the project-local metro-config package.', { cause });
+    }
+    if (typeof metroConfig.resolveConfig !== 'function') {
+        const version = (() => {
+            try {
+                return projectRequire('metro-config/package.json').version;
+            }
+            catch {
+                return 'unknown';
+            }
+        })();
+        throw new Error(`metro-config ${version} does not expose resolveConfig().`);
+    }
+    const hadMetroTarget = Object.hasOwn(process.env, 'EXPO_METRO_TARGET');
+    const previousMetroTarget = process.env.EXPO_METRO_TARGET;
+    let resolved;
+    try {
+        process.env.EXPO_METRO_TARGET = 'harmony';
+        resolved = await metroConfig.resolveConfig(undefined, projectRoot);
+    }
+    finally {
+        if (hadMetroTarget)
+            process.env.EXPO_METRO_TARGET = previousMetroTarget;
+        else
+            delete process.env.EXPO_METRO_TARGET;
+    }
+    const config = resolved?.config;
+    const platforms = config?.resolver?.platforms;
+    const conditions = config?.resolver?.unstable_conditionsByPlatform?.harmony;
+    if (!Array.isArray(platforms) || !platforms.includes('harmony')
+        || !Array.isArray(conditions) || !conditions.includes('harmony')
+        || typeof config?.resolver?.resolveRequest !== 'function') {
+        throw new Error('The resolved Metro config must register the harmony platform, Harmony conditions, and a resolver.');
+    }
+}
+async function doctorUnlockedAsync(projectRoot, options = {}) {
+    const checks = [];
+    const unavailableToolStatus = options.requireBuildTools ? 'error' : 'warn';
+    let config;
+    try {
+        config = (0, config_1.getConfig)(projectRoot, {
+            isModdedConfig: true,
+            skipSDKVersionRequirement: true,
+        }).exp;
+        (0, config_plugins_1.normalizeHarmonyConfig)(config);
+        checks.push(check('app-config', 'pass', 'Harmony app config is valid.'));
+    }
+    catch (error) {
+        checks.push(check('app-config', 'error', error.message, { code: error.code || 'ERR_HARMONY_CONFIG_INVALID' }));
+    }
+    if (config) {
+        checks.push(hasPlugin(config.plugins, '@expo-harmony/prebuild-config')
+            ? check('config-plugin', 'pass', '@expo-harmony/prebuild-config is registered.')
+            : check('config-plugin', 'error', 'Add @expo-harmony/prebuild-config to expo.plugins.'));
+        const harmony = config.harmony;
+        if (harmony?.signingConfigFile) {
+            try {
+                const signing = await (0, signing_1.validateHarmonySigningConfigFile)(projectRoot, harmony.signingConfigFile);
+                checks.push(check('signing', 'pass', `Harmony signing config ${signing.name} is valid.`));
+            }
+            catch (error) {
+                checks.push(check('signing', 'error', error.message, { code: error.code || 'ERR_HARMONY_SIGNING_INVALID' }));
+            }
+        }
+        else {
+            checks.push(check('signing', 'warn', 'No external signing config is set; unsigned generation remains available.'));
+        }
+    }
+    try {
+        await validateMetroConfigAsync(projectRoot);
+        checks.push(check('metro', 'pass', 'The resolved Metro config enables Harmony.'));
+    }
+    catch (error) {
+        checks.push(check('metro', 'error', `Cannot load a Harmony-enabled Metro config: ${error.message}`, { code: error.code || 'ERR_HARMONY_METRO_CONFIG' }));
+    }
+    for (const packageName of upstream_1.RequiredProjectPackages) {
+        if (canResolvePackage(projectRoot, packageName)) {
+            checks.push(check(`package:${packageName}`, 'pass', `${packageName} is resolvable.`));
+        }
+        else {
+            checks.push(check(`package:${packageName}`, 'error', `${packageName} is not resolvable from the app.`));
+        }
+    }
+    if (options.validateModules !== false) {
+        try {
+            const result = await (0, expo_modules_autolinking_1.verifyModulesAsync)({ platform: 'harmony', projectRoot });
+            const errors = result.diagnostics.filter(item => item.severity === 'error');
+            const warnings = result.diagnostics.filter(item => item.severity === 'warning');
+            if (errors.length > 0) {
+                checks.push(check('expo-modules', 'error', `Harmony Expo Modules verification found ${errors.length} error(s). Run 'expo-harmony modules verify' for details.`, { diagnostics: result.diagnostics }));
+            }
+            else if (warnings.length > 0) {
+                checks.push(check('expo-modules', 'warn', `Verified ${result.modules.length} Harmony native module(s) with ${warnings.length} warning(s).`, { diagnostics: warnings }));
+            }
+            else {
+                checks.push(check('expo-modules', 'pass', `Verified ${result.modules.length} Harmony native module(s).`));
+            }
+        }
+        catch (error) {
+            checks.push(check('expo-modules', 'error', `Harmony Expo Modules verification failed: ${error.message}`, { code: error.code || 'ERR_HARMONY_AUTOLINKING_FAILED' }));
+        }
+    }
+    const toolchain = (0, tools_1.resolveHarmonyToolchain)();
+    let sdkCheck;
+    if (toolchain.sdkHome) {
+        sdkCheck = check('harmony-sdk', 'pass', `Complete Harmony SDK root was resolved at ${toolchain.sdkHome}.`);
+    }
+    else {
+        sdkCheck = check('harmony-sdk', unavailableToolStatus, 'No complete Harmony SDK root with HMS and OpenHarmony components was found; generation works but HAP build cannot be verified.');
+    }
+    checks.push(sdkCheck);
+    const tools = [
+        ['ohpm', toolchain.ohpm, ['--version'], unavailableToolStatus],
+        ['hvigor-command', toolchain.hvigor, ['--version'], unavailableToolStatus],
+    ];
+    if (options.requireDeviceTools !== false) {
+        tools.unshift(['hdc', toolchain.hdc, ['-v'], unavailableToolStatus]);
+    }
+    for (const [id, tool, versionArgs, unavailableStatus] of tools) {
+        try {
+            const result = await (0, process_1.spawnAsync)(tool.command, [...tool.args, ...versionArgs], {
+                capture: true,
+                cwd: projectRoot,
+                operation: `doctor-${id}`,
+                timeoutMs: 10_000,
+            });
+            checks.push(result.code === 0 && !result.timedOut
+                ? check(id, 'pass', `${tool.command} is available through ${tool.source}.`)
+                : check(id, unavailableStatus, `${tool.command} is unavailable or unhealthy; HAP build cannot be verified.`));
+        }
+        catch {
+            checks.push(check(id, unavailableStatus, `${tool.command} is unavailable; generation remains available.`));
+        }
+    }
+    if (options.validateGeneratedProject !== false) {
+        try {
+            const plan = await (0, tools_1.resolveHarmonyBuildPlanIfPresentAsync)(projectRoot);
+            if (plan && node_fs_1.default.existsSync(plan.harmonyRoot)) {
+                if (!node_fs_1.default.existsSync(plan.projectFiles.rootHvigor)
+                    || !node_fs_1.default.existsSync(plan.projectFiles.moduleHvigor)) {
+                    checks.push(check('hvigor', 'error', 'Generated root and module Hvigor files are required.'));
+                }
+                else {
+                    const content = await node_fs_1.default.promises.readFile(plan.projectFiles.moduleHvigor, 'utf8');
+                    checks.push((0, native_project_1.isRnohAutolinkingDisabled)(content)
+                        ? check('hvigor-autolinking', 'pass', 'RNOH duplicate autolinking is disabled.')
+                        : check('hvigor-autolinking', 'error', 'The generated module Hvigor file must disable RNOH autolinking.'));
+                }
+            }
+        }
+        catch (error) {
+            checks.push(check('harmony-project', 'error', error.message, { code: error.code || 'ERR_HARMONY_TEMPLATE_INVALID' }));
+        }
+    }
+    return {
+        checks,
+        ok: checks.every(item => item.status !== 'error'),
+        projectRoot,
+    };
+}
+async function doctorAsync(projectRoot, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(projectRoot, 'doctor', () => doctorUnlockedAsync(projectRoot, options));
+}
+function formatDoctor(result) {
+    return result.checks.map((item) => {
+        const symbol = item.status === 'pass' ? '✓' : item.status === 'warn' ? '!' : '✗';
+        return `${symbol} [${item.status}] ${item.message}`;
+    }).join('\n');
+}

package/build/doctor/options.d.ts

@@ -0,0 +1,5 @@
+declare function parseDoctorArgs(argv: string[]): {
+    help: boolean;
+    project: string;
+};
+export { parseDoctorArgs };

package/build/doctor/options.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDoctorArgs = parseDoctorArgs;
+const args_1 = require("../args");
+const errors_1 = require("../errors");
+function parseDoctorArgs(argv) {
+    const { positionals, values } = (0, args_1.parseArgs)(args_1.CommonOptions, argv);
+    if (positionals.length > 1) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unexpected doctor positional argument: ${positionals[1]}`, { operation: 'parse-arguments' });
+    }
+    return {
+        help: Boolean(values.help),
+        project: positionals[0],
+    };
+}

package/build/entry.d.ts

@@ -0,0 +1,2 @@
+declare function resolveHarmonyEntryPoint(projectRoot: any): string;
+export { resolveHarmonyEntryPoint };

package/build/entry.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHarmonyEntryPoint = resolveHarmonyEntryPoint;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("@expo/config/paths");
+const errors_1 = require("./errors");
+function isFile(file) {
+    try {
+        return node_fs_1.default.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function resolveHarmonyEntryPoint(projectRoot) {
+    const packageJsonPath = node_path_1.default.join(projectRoot, 'package.json');
+    try {
+        const pkg = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+        let entry = (0, paths_1.resolveEntryPoint)(projectRoot, { pkg, platform: 'harmony' });
+        if (!isFile(entry) && typeof pkg.main === 'string' && pkg.main) {
+            const logicalPackageRoot = entry;
+            const resolved = (0, node_module_1.createRequire)(packageJsonPath).resolve(pkg.main);
+            try {
+                const relative = node_path_1.default.relative(node_fs_1.default.realpathSync(logicalPackageRoot), node_fs_1.default.realpathSync(resolved));
+                entry = relative !== '..'
+                    && !relative.startsWith(`..${node_path_1.default.sep}`)
+                    && !node_path_1.default.isAbsolute(relative)
+                    ? node_path_1.default.join(logicalPackageRoot, relative)
+                    : resolved;
+            }
+            catch {
+                entry = resolved;
+            }
+        }
+        if (!isFile(entry))
+            throw new Error('Resolved entry is not a file.');
+        return entry;
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_ENTRY', 'Cannot resolve the Expo entry point for the Harmony bundle.', { cause, operation: 'resolve-entry-point' });
+    }
+}

package/build/errors.d.ts

@@ -0,0 +1,12 @@
+interface HarmonyCliErrorOptions {
+    cause?: unknown;
+    exitCode?: number;
+    operation?: string;
+}
+declare class HarmonyCliError extends Error {
+    code: string;
+    exitCode: number;
+    operation: string;
+    constructor(code: string, message: string, options?: HarmonyCliErrorOptions);
+}
+export { HarmonyCliError };

package/build/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyCliError = void 0;
+class HarmonyCliError extends Error {
+    code;
+    exitCode;
+    operation;
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'HarmonyCliError';
+        this.code = code;
+        this.exitCode = options.exitCode || 1;
+        this.operation = options.operation || 'cli';
+    }
+}
+exports.HarmonyCliError = HarmonyCliError;

package/build/expo.d.ts

@@ -0,0 +1,19 @@
+interface ExpoHermesBundleOptions {
+    code: string;
+    filename: string;
+    map: string | null;
+    minify?: boolean;
+    projectRoot: string;
+}
+interface ExpoHermesBundleOutput {
+    hbc: Uint8Array;
+    sourcemap: string | null;
+}
+type ExpoHermesBuilder = (options: ExpoHermesBundleOptions) => Promise<ExpoHermesBundleOutput>;
+declare function resolveExpoCli(projectRoot: any): {
+    cliPath: string;
+    packageJsonPath: any;
+};
+declare function resolveExpoHermesBuilder(projectRoot: string): ExpoHermesBuilder;
+export { resolveExpoCli, resolveExpoHermesBuilder };
+export type { ExpoHermesBuilder };

package/build/expo.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExpoCli = resolveExpoCli;
+exports.resolveExpoHermesBuilder = resolveExpoHermesBuilder;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+function resolveExpoCli(projectRoot) {
+    const projectRequire = (0, node_module_1.createRequire)(node_path_1.default.join(projectRoot, 'package.json'));
+    let packageJsonPath;
+    try {
+        packageJsonPath = projectRequire.resolve('expo/package.json');
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPO_CLI_NOT_FOUND', 'Cannot resolve the project-local expo package.', { cause, operation: 'resolve-expo-cli' });
+    }
+    const packageJson = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+    const bin = typeof packageJson.bin === 'string' ? packageJson.bin : packageJson.bin?.expo;
+    if (typeof bin !== 'string' || !bin) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPO_CLI_NOT_FOUND', 'The project-local expo package has no expo binary.', { operation: 'resolve-expo-cli' });
+    }
+    const cliPath = node_path_1.default.resolve(node_path_1.default.dirname(packageJsonPath), bin);
+    if (!node_fs_1.default.existsSync(cliPath)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPO_CLI_NOT_FOUND', `Expo CLI binary does not exist: ${cliPath}`, { operation: 'resolve-expo-cli' });
+    }
+    return { cliPath, packageJsonPath };
+}
+function resolveExpoHermesBuilder(projectRoot) {
+    const projectRequire = (0, node_module_1.createRequire)(node_path_1.default.join(projectRoot, 'package.json'));
+    let packageJsonPath;
+    try {
+        packageJsonPath = projectRequire.resolve('@expo/metro-config/package.json');
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_HERMES', 'Cannot resolve the project-local @expo/metro-config package required for Hermes export.', { cause, operation: 'resolve-expo-hermes' });
+    }
+    const modulePath = node_path_1.default.join(node_path_1.default.dirname(packageJsonPath), 'build', 'serializer', 'exportHermes.js');
+    let moduleExports;
+    try {
+        moduleExports = projectRequire(modulePath);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_HERMES', `Cannot load the Expo Hermes exporter: ${modulePath}`, { cause, operation: 'resolve-expo-hermes' });
+    }
+    if (typeof moduleExports?.buildHermesBundleAsync !== 'function') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_HERMES', 'The project-local @expo/metro-config package does not expose buildHermesBundleAsync().', { operation: 'resolve-expo-hermes' });
+    }
+    return moduleExports.buildHermesBundleAsync;
+}

package/build/exportEmbed/export.d.ts

@@ -0,0 +1,16 @@
+import { type HarmonyExportManifest } from './manifest';
+export interface ExportOptions {
+    check?: boolean;
+    resetCache?: boolean;
+    skipDoctor?: boolean;
+    timeoutMs?: number;
+}
+export interface ExportTemporary {
+    assets: string;
+    bundle: string;
+    javascript: string;
+    metroSourceMap: string;
+    sourceMap: string;
+}
+declare function exportEmbedAsync(projectRoot: string, options?: ExportOptions): Promise<HarmonyExportManifest>;
+export { exportEmbedAsync, };

package/build/exportEmbed/export.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportEmbedAsync = exportEmbedAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const doctor_1 = require("../doctor/doctor");
+const entry_1 = require("../entry");
+const errors_1 = require("../errors");
+const projectLock_1 = require("../projectLock");
+const tools_1 = require("../tools");
+const process_1 = require("../process");
+const expo_1 = require("../expo");
+const manifest_1 = require("./manifest");
+function createExpoExportEmbedArgs(projectRoot, entryFile, temporary, options = {}) {
+    return [
+        'export:embed',
+        '--platform', 'harmony',
+        '--entry-file', entryFile,
+        '--bundle-output', temporary.javascript,
+        '--assets-dest', temporary.assets,
+        '--dev', 'false',
+        '--minify', 'false',
+        '--sourcemap-output', temporary.metroSourceMap,
+        '--sourcemap-sources-root', '.',
+        '--unstable-transform-profile', 'hermes-stable',
+        ...(options.resetCache ? ['--reset-cache=true'] : []),
+        projectRoot,
+    ];
+}
+function assertDoctor(result) {
+    if (result.ok)
+        return;
+    const failing = result.checks.filter(check => check.status === 'error').map(check => check.id);
+    throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_DOCTOR', `Harmony doctor found blocking checks: ${failing.join(', ') || 'unknown'}.`, { operation: 'doctor' });
+}
+async function exportEmbedUnlockedAsync(projectRoot, options = {}) {
+    if (!options.skipDoctor)
+        assertDoctor(await (0, doctor_1.doctorAsync)(projectRoot));
+    const plan = await (0, tools_1.resolveHarmonyBuildPlanAsync)(projectRoot, { buildMode: 'release' });
+    const paths = (0, manifest_1.exportPaths)(plan);
+    if (options.check)
+        return await (0, manifest_1.validatePublishedExportAsync)(paths);
+    const entryFile = (0, entry_1.resolveHarmonyEntryPoint)(projectRoot);
+    const temporaryRoot = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'expo-harmony-export-'));
+    const temporary = {
+        assets: node_path_1.default.join(temporaryRoot, 'assets'),
+        bundle: node_path_1.default.join(temporaryRoot, 'hermes_bundle.hbc'),
+        javascript: node_path_1.default.join(temporaryRoot, 'index.js'),
+        metroSourceMap: node_path_1.default.join(temporaryRoot, 'index.js.map'),
+        sourceMap: node_path_1.default.join(temporaryRoot, 'hermes_bundle.hbc.map'),
+    };
+    try {
+        await node_fs_1.default.promises.mkdir(temporary.assets, { recursive: true });
+        const expo = (0, expo_1.resolveExpoCli)(projectRoot);
+        const result = await (0, process_1.spawnAsync)(process.execPath, [
+            expo.cliPath,
+            ...createExpoExportEmbedArgs(projectRoot, entryFile, temporary, options),
+        ], {
+            capture: true,
+            cwd: projectRoot,
+            env: {
+                ...process.env,
+                EXPO_METRO_TARGET: 'harmony',
+                HERMES_V1_ENABLED: 'true',
+                NODE_ENV: 'production',
+            },
+            operation: 'expo-export-embed',
+            outputLimit: 4 * 1024 * 1024,
+            timeoutMs: options.timeoutMs || 10 * 60_000,
+        });
+        if (result.code !== 0 || result.timedOut) {
+            const diagnostics = (0, process_1.formatDiagnostics)(result);
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_FAILED', `Expo export:embed exited with code ${result.code}${result.timedOut ? ' after timing out' : ''}.${diagnostics ? `\n${diagnostics}` : ''}`, { exitCode: result.code || 1, operation: 'expo-export-embed' });
+        }
+        // Expo 55 only infers Hermes for iOS and Android. Keep Harmony bundling in the Expo CLI,
+        // then explicitly hand its JS and source map to Expo's own Hermes exporter.
+        try {
+            const [code, map] = await Promise.all([
+                node_fs_1.default.promises.readFile(temporary.javascript, 'utf8'),
+                node_fs_1.default.promises.readFile(temporary.metroSourceMap, 'utf8'),
+            ]);
+            const buildHermesBundleAsync = (0, expo_1.resolveExpoHermesBuilder)(projectRoot);
+            // Expo resolves hermes-compiler from react-native. For Harmony, resolve it
+            // from RNOH instead of the app's Android/iOS React Native installation.
+            const projectRequire = (0, node_module_1.createRequire)(node_path_1.default.join(projectRoot, 'package.json'));
+            const harmonyRuntime = node_path_1.default.dirname(projectRequire.resolve('@react-native-oh/react-native-harmony/package.json'));
+            const compilerModules = node_path_1.default.join(temporaryRoot, 'node_modules');
+            await node_fs_1.default.promises.mkdir(compilerModules);
+            await node_fs_1.default.promises.symlink(harmonyRuntime, node_path_1.default.join(compilerModules, 'react-native'), process.platform === 'win32' ? 'junction' : 'dir');
+            const output = await buildHermesBundleAsync({
+                code,
+                filename: entryFile,
+                map,
+                minify: true,
+                projectRoot: temporaryRoot,
+            });
+            if (!(output?.hbc instanceof Uint8Array) || typeof output.sourcemap !== 'string') {
+                throw new Error('Expo did not return Hermes bytecode and a composed source map.');
+            }
+            await Promise.all([
+                node_fs_1.default.promises.writeFile(temporary.bundle, output.hbc),
+                node_fs_1.default.promises.writeFile(temporary.sourceMap, output.sourcemap),
+            ]);
+        }
+        catch (cause) {
+            if (cause instanceof errors_1.HarmonyCliError)
+                throw cause;
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_HERMES', 'Expo failed to compile the Harmony bundle to Hermes bytecode.', { cause, operation: 'expo-hermes-export' });
+        }
+        const bytecode = await (0, manifest_1.assertHermesBundle)(temporary.bundle);
+        await (0, manifest_1.assertSourceMap)(temporary.sourceMap);
+        return await (0, manifest_1.publishExportAsync)(projectRoot, paths, temporary, entryFile, bytecode);
+    }
+    finally {
+        await node_fs_1.default.promises.rm(temporaryRoot, { force: true, recursive: true });
+    }
+}
+async function exportEmbedAsync(projectRoot, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(projectRoot, 'export:embed', () => exportEmbedUnlockedAsync(projectRoot, options));
+}

package/build/exportEmbed/manifest.d.ts

@@ -0,0 +1,44 @@
+import type { ExportTemporary } from './export';
+export interface HarmonyExportFile {
+    path: string;
+    sha256: string;
+    size: number;
+}
+export interface HarmonyExportManifest {
+    assets: HarmonyExportFile[];
+    bundle: HarmonyExportFile & {
+        bytecodeVersion: number;
+    };
+    entryFile: string;
+    platform: 'harmony';
+    schemaVersion: 1;
+    sourceMap: HarmonyExportFile;
+    transformProfile: 'hermes-stable';
+}
+declare const HermesMagic: Buffer;
+declare function exportPaths(plan: {
+    exportPaths: {
+        bundle: string;
+        manifest: string;
+        metadataRoot: string;
+        rawfileRoot: string;
+        sourceMap: string;
+    };
+}): {
+    bundle: string;
+    manifest: string;
+    metadataRoot: string;
+    rawfileRoot: string;
+    sourceMap: string;
+};
+declare function assertHermesBundle(file: any): Promise<{
+    bytecodeVersion: number;
+    size: any;
+}>;
+declare function assertSourceMap(file: any): Promise<{
+    sha256: string;
+    size: number;
+}>;
+declare function publishExportAsync(projectRoot: string, paths: ReturnType<typeof exportPaths>, temporary: ExportTemporary, entryFile: string, bytecode: Awaited<ReturnType<typeof assertHermesBundle>>): Promise<HarmonyExportManifest>;
+declare function validatePublishedExportAsync(paths: ReturnType<typeof exportPaths>): Promise<HarmonyExportManifest>;
+export { HermesMagic, assertHermesBundle, assertSourceMap, exportPaths, publishExportAsync, validatePublishedExportAsync, };