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

package/build/development/protocol.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyManifestPath = void 0;
+exports.canonicalHarmonyManifestURL = canonicalHarmonyManifestURL;
+exports.createHarmonyLaunchLink = createHarmonyLaunchLink;
+const errors_1 = require("../errors");
+exports.HarmonyManifestPath = '/manifest';
+function canonicalHarmonyManifestURL(value) {
+    let url;
+    try {
+        url = new URL(value);
+        decodeURIComponent(url.search);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_URL', 'Expected an absolute HTTP(S) Harmony manifest URL.', { cause, operation: 'development-manifest' });
+    }
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.hash
+        || !['/', exports.HarmonyManifestPath, '/index.exp'].includes(url.pathname)
+        || url.searchParams.getAll('platform').length !== 1 || url.searchParams.get('platform') !== 'harmony') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_URL', 'Expected an HTTP(S) Expo manifest URL with platform=harmony and without credentials or a fragment.', { operation: 'development-manifest' });
+    }
+    url.pathname = exports.HarmonyManifestPath;
+    // Keep all other query values (including repetitions) in order. Platform has
+    // one canonical position, and URLSearchParams normalizes equivalent encoding.
+    url.searchParams.delete('platform');
+    url.searchParams.append('platform', 'harmony');
+    return url.toString();
+}
+function createHarmonyLaunchLink(manifest) {
+    const url = new URL('expo-harmony://open');
+    url.searchParams.set('url', canonicalHarmonyManifestURL(manifest));
+    return url.toString();
+}

package/build/development/session.d.ts

@@ -0,0 +1,5 @@
+export declare function readDevelopmentSessionAsync(root: string, port: number, hostname?: string): Promise<{
+    manifestUrl: string;
+    launchLink: string;
+    bundleUrl: string;
+}>;

package/build/development/session.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDevelopmentSessionAsync = readDevelopmentSessionAsync;
+const node_http_1 = __importDefault(require("node:http"));
+const node_os_1 = __importDefault(require("node:os"));
+const errors_1 = require("../errors");
+const config_1 = require("../runtime/config");
+const protocol_1 = require("./protocol");
+async function readDevelopmentSessionAsync(root, port, hostname) {
+    const project = await (0, config_1.readProjectRuntimeAsync)(root);
+    const { config } = project;
+    const host = hostname || process.env.REACT_NATIVE_PACKAGER_HOSTNAME
+        || Object.values(node_os_1.default.networkInterfaces()).flat().find(item => item?.family === 'IPv4' && !item.internal)?.address
+        || '127.0.0.1';
+    if (!/^[A-Za-z0-9.-]+$/.test(host)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_HOST', 'Harmony development requires an HTTP LAN hostname or IPv4 address.', { operation: 'development-manifest' });
+    }
+    const manifest = await new Promise((resolve, reject) => {
+        const request = node_http_1.default.get({
+            host: '127.0.0.1',
+            port,
+            path: `${protocol_1.HarmonyManifestPath}?platform=harmony`,
+            headers: { 'host': `${host}:${port}`, 'accept': 'application/json', 'expo-platform': 'harmony', 'expo-protocol-version': '0' },
+        }, (response) => {
+            let body = '';
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => {
+                body += chunk;
+                if (body.length > 2 * 1024 * 1024)
+                    request.destroy(new Error('Harmony manifest exceeded 2 MB.'));
+            });
+            response.on('error', reject);
+            response.on('end', () => {
+                try {
+                    const value = JSON.parse(body);
+                    if (response.statusCode !== 200 || response.headers['expo-protocol-version'] !== '0'
+                        || !response.headers['content-type']?.startsWith('application/json')) {
+                        reject(new Error(value.error?.message || 'Metro did not return an Expo development manifest with protocol version 0.'));
+                        return;
+                    }
+                    resolve(value);
+                }
+                catch (cause) {
+                    reject(new Error('Metro did not return a valid Harmony manifest.', { cause }));
+                }
+            });
+        });
+        request.setTimeout(60_000, () => request.destroy(new Error('Harmony manifest request timed out.')));
+        request.on('error', reject);
+    }).catch((cause) => {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_METRO_MANIFEST', `Cannot use this Metro server: ${cause.message}`, { cause, operation: 'development-manifest' });
+    });
+    const identity = config.extra?.eas?.projectId || `@${config.owner || 'anonymous'}/${config.slug}/${project.bundleName}`;
+    if (manifest.extra?.harmony?.projectId !== identity
+        || manifest.runtimeVersion !== project.runtimeVersion) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_METRO_PROJECT', 'This Metro server belongs to another Harmony project.', { operation: 'development-manifest' });
+    }
+    return {
+        manifestUrl: manifest.extra.harmony.manifestUrl,
+        launchLink: (0, protocol_1.createHarmonyLaunchLink)(manifest.extra.harmony.manifestUrl),
+        bundleUrl: manifest.launchAsset.url,
+    };
+}

package/build/doctor/doctor.d.ts

@@ -0,0 +1,20 @@
+export interface DoctorCheck {
+    details?: unknown;
+    id: string;
+    message: string;
+    status: 'error' | 'pass' | 'warn';
+}
+export interface DoctorResult {
+    checks: DoctorCheck[];
+    ok: boolean;
+    projectRoot: string;
+}
+interface DoctorOptions {
+    requireBuildTools?: boolean;
+    requireDeviceTools?: boolean;
+    validateGeneratedProject?: boolean;
+    validateModules?: boolean;
+}
+declare function doctorAsync(root: string, options?: DoctorOptions): Promise<DoctorResult>;
+declare function formatDoctor(result: DoctorResult): string;
+export { doctorAsync, formatDoctor };

package/build/doctor/doctor.js

@@ -0,0 +1,226 @@
+"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 internal_1 = require("@expo-harmony/prebuild-config/internal");
+const process_1 = require("../process");
+const projectLock_1 = require("../projectLock");
+const project_1 = require("../native/project");
+const toolchain_1 = require("../native/toolchain");
+const upstream_1 = require("../upstream");
+const bare_1 = require("../native/bare");
+function hasPlugin(plugins, name) {
+    return (plugins || []).some(plugin => (Array.isArray(plugin) ? plugin[0] : plugin) === name);
+}
+function check(id, status, message, details) {
+    return { id, status, message, ...(details ? { details } : {}) };
+}
+function canResolvePackage(root, name) {
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    try {
+        require.resolve(`${name}/package.json`);
+        return true;
+    }
+    catch {
+        try {
+            require.resolve(name);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+async function validateMetroConfigAsync(root) {
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    let metro;
+    try {
+        metro = require('metro-config');
+    }
+    catch (cause) {
+        throw new Error('Cannot load the project-local metro-config package.', { cause });
+    }
+    if (typeof metro.resolveConfig !== 'function') {
+        const version = (() => {
+            try {
+                return require('metro-config/package.json').version;
+            }
+            catch {
+                return 'unknown';
+            }
+        })();
+        throw new Error(`metro-config ${version} does not expose resolveConfig().`);
+    }
+    const present = Object.hasOwn(process.env, 'EXPO_METRO_TARGET');
+    const previous = process.env.EXPO_METRO_TARGET;
+    let resolved;
+    try {
+        process.env.EXPO_METRO_TARGET = 'harmony';
+        resolved = await metro.resolveConfig(undefined, root);
+    }
+    finally {
+        if (present)
+            process.env.EXPO_METRO_TARGET = previous;
+        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(root, options = {}) {
+    const checks = [];
+    const unavailable = options.requireBuildTools ? 'error' : 'warn';
+    let config;
+    const bare = (0, bare_1.isBareHarmonyProject)(root);
+    try {
+        if (bare) {
+            const plan = await (0, project_1.resolveHarmonyBuildPlanIfPresentAsync)(root);
+            checks.push(check('native-config', 'pass', `Bare Harmony project: ${plan.bundleName} / ${plan.moduleName}. Native files own the configuration.`));
+        }
+        else {
+            config = (0, config_1.getConfig)(root, {
+                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(bare ? 'native-config' : '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, internal_1.validateHarmonySigningConfigFile)(root, 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(root);
+        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 name of upstream_1.RequiredProjectPackages) {
+        if (canResolvePackage(root, name)) {
+            checks.push(check(`package:${name}`, 'pass', `${name} is resolvable.`));
+        }
+        else {
+            checks.push(check(`package:${name}`, 'error', `${name} is not resolvable from the app.`));
+        }
+    }
+    if (options.validateModules !== false) {
+        try {
+            const result = await (0, expo_modules_autolinking_1.verifyModulesAsync)({ platform: 'harmony', projectRoot: root });
+            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, toolchain_1.resolveHarmonyToolchain)();
+    let sdk;
+    if (toolchain.sdkHome) {
+        sdk = check('harmony-sdk', 'pass', `Complete Harmony SDK root was resolved at ${toolchain.sdkHome}.`);
+    }
+    else {
+        sdk = check('harmony-sdk', unavailable, 'No complete Harmony SDK root with HMS and OpenHarmony components was found; generation works but HAP build cannot be verified.');
+    }
+    checks.push(sdk);
+    const tools = [
+        ['ohpm', toolchain.ohpm, ['--version'], unavailable],
+        ['hvigor-command', toolchain.hvigor, ['--version'], unavailable],
+    ];
+    if (options.requireDeviceTools !== false) {
+        tools.unshift(['hdc', toolchain.hdc, ['-v'], unavailable]);
+    }
+    for (const [id, tool, args, status] of tools) {
+        const command = [tool.command, ...tool.args].map(value => JSON.stringify(value)).join(' ');
+        try {
+            const result = await (0, process_1.spawnAsync)(tool.command, [...tool.args, ...args], {
+                capture: true,
+                cwd: root,
+                operation: `doctor-${id}`,
+                timeoutMs: 10_000,
+            });
+            checks.push(result.code === 0 && !result.timedOut
+                ? check(id, 'pass', `${command} is available through ${tool.source}.`)
+                : check(id, status, `${command} is unavailable or unhealthy; HAP build cannot be verified.`));
+        }
+        catch {
+            checks.push(check(id, status, `${command} is unavailable; generation remains available.`));
+        }
+    }
+    if (options.validateGeneratedProject !== false) {
+        try {
+            const plan = await (0, project_1.resolveHarmonyBuildPlanIfPresentAsync)(root);
+            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', 'Root and module Hvigor files are required.'));
+                }
+                else {
+                    const content = await node_fs_1.default.promises.readFile(plan.projectFiles.moduleHvigor, 'utf8');
+                    checks.push((0, internal_1.isRnohAutolinkingDisabled)(content)
+                        ? check('hvigor-autolinking', 'pass', 'RNOH duplicate autolinking is disabled.')
+                        : check('hvigor-autolinking', 'error', 'The module Hvigor file must disable duplicate 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: root,
+    };
+}
+async function doctorAsync(root, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(root, 'doctor', () => doctorUnlockedAsync(root, 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/index.d.ts

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

package/build/doctor/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.parseDoctorArgs, argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root } = args;
+    const { doctorAsync, formatDoctor } = await import('./doctor.js');
+    const result = await doctorAsync(root, { requireBuildTools: true });
+    io.log(formatDoctor(result));
+    return result.ok ? 0 : 1;
+};
+exports.command = command;

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,18 @@
+import { type HarmonyExportManifest } from './manifest';
+export interface ExportOptions {
+    check?: boolean;
+    outputDirectory?: string;
+    resetCache?: boolean;
+    skipDoctor?: boolean;
+    timeoutMs?: number;
+}
+export interface ExportTemporary {
+    assets: string;
+    bundle: string;
+    javascript: string;
+    metroSourceMap: string;
+    metadata: string;
+    sourceMap: string;
+}
+declare function exportEmbedAsync(root: string, options?: ExportOptions): Promise<HarmonyExportManifest>;
+export { exportEmbedAsync };