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

package/build/command.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommandArgs = parseCommandArgs;
+const node_path_1 = __importDefault(require("node:path"));
+const help_1 = require("./help");
+const project_1 = require("./project");
+function parseCommandArgs(parse, argv, io) {
+    const options = parse(argv);
+    if (options.help) {
+        io.log(help_1.Help);
+        return null;
+    }
+    return {
+        options,
+        projectRoot: (0, project_1.resolveProject)(options.project ? node_path_1.default.resolve(options.project) : process.cwd()),
+    };
+}

package/build/doctor/doctor.d.ts

@@ -15,6 +15,6 @@ interface DoctorOptions {
     validateGeneratedProject?: boolean;
     validateModules?: boolean;
 }
-declare function doctorAsync(projectRoot: string, options?: DoctorOptions): Promise<DoctorResult>;
+declare function doctorAsync(root: string, options?: DoctorOptions): Promise<DoctorResult>;
 declare function formatDoctor(result: DoctorResult): string;
 export { doctorAsync, formatDoctor };

package/build/doctor/doctor.js

@@ -11,27 +11,28 @@ 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 internal_1 = require("@expo-harmony/prebuild-config/internal");
 const process_1 = require("../process");
 const projectLock_1 = require("../projectLock");
-const tools_1 = require("../tools");
+const project_1 = require("../native/project");
+const toolchain_1 = require("../native/toolchain");
 const upstream_1 = require("../upstream");
-function hasPlugin(plugins, packageName) {
-    return (plugins || []).some(plugin => (Array.isArray(plugin) ? plugin[0] : plugin) === packageName);
+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(projectRoot, packageName) {
-    const projectRequire = (0, node_module_1.createRequire)(node_path_1.default.join(projectRoot, 'package.json'));
+function canResolvePackage(root, name) {
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
     try {
-        projectRequire.resolve(`${packageName}/package.json`);
+        require.resolve(`${name}/package.json`);
         return true;
     }
     catch {
         try {
-            projectRequire.resolve(packageName);
+            require.resolve(name);
             return true;
         }
         catch {
@@ -39,19 +40,19 @@ function canResolvePackage(projectRoot, packageName) {
         }
     }
 }
-async function validateMetroConfigAsync(projectRoot) {
-    const projectRequire = (0, node_module_1.createRequire)(node_path_1.default.join(projectRoot, 'package.json'));
-    let metroConfig;
+async function validateMetroConfigAsync(root) {
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    let metro;
     try {
-        metroConfig = projectRequire('metro-config');
+        metro = require('metro-config');
     }
     catch (cause) {
         throw new Error('Cannot load the project-local metro-config package.', { cause });
     }
-    if (typeof metroConfig.resolveConfig !== 'function') {
+    if (typeof metro.resolveConfig !== 'function') {
         const version = (() => {
             try {
-                return projectRequire('metro-config/package.json').version;
+                return require('metro-config/package.json').version;
             }
             catch {
                 return 'unknown';
@@ -59,16 +60,16 @@ async function validateMetroConfigAsync(projectRoot) {
         })();
         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;
+    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 metroConfig.resolveConfig(undefined, projectRoot);
+        resolved = await metro.resolveConfig(undefined, root);
     }
     finally {
-        if (hadMetroTarget)
-            process.env.EXPO_METRO_TARGET = previousMetroTarget;
+        if (present)
+            process.env.EXPO_METRO_TARGET = previous;
         else
             delete process.env.EXPO_METRO_TARGET;
     }
@@ -81,20 +82,27 @@ async function validateMetroConfigAsync(projectRoot) {
         throw new Error('The resolved Metro config must register the harmony platform, Harmony conditions, and a resolver.');
     }
 }
-async function doctorUnlockedAsync(projectRoot, options = {}) {
+async function doctorUnlockedAsync(root, options = {}) {
     const checks = [];
-    const unavailableToolStatus = options.requireBuildTools ? 'error' : 'warn';
+    const unavailable = options.requireBuildTools ? 'error' : 'warn';
     let config;
+    const bare = (0, bare_1.isBareHarmonyProject)(root);
     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.'));
+        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('app-config', 'error', error.message, { code: error.code || 'ERR_HARMONY_CONFIG_INVALID' }));
+        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')
@@ -103,7 +111,7 @@ async function doctorUnlockedAsync(projectRoot, options = {}) {
         const harmony = config.harmony;
         if (harmony?.signingConfigFile) {
             try {
-                const signing = await (0, signing_1.validateHarmonySigningConfigFile)(projectRoot, harmony.signingConfigFile);
+                const signing = await (0, internal_1.validateHarmonySigningConfigFile)(root, harmony.signingConfigFile);
                 checks.push(check('signing', 'pass', `Harmony signing config ${signing.name} is valid.`));
             }
             catch (error) {
@@ -115,23 +123,23 @@ async function doctorUnlockedAsync(projectRoot, options = {}) {
         }
     }
     try {
-        await validateMetroConfigAsync(projectRoot);
+        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 packageName of upstream_1.RequiredProjectPackages) {
-        if (canResolvePackage(projectRoot, packageName)) {
-            checks.push(check(`package:${packageName}`, 'pass', `${packageName} is resolvable.`));
+    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:${packageName}`, 'error', `${packageName} is not resolvable from the app.`));
+            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 });
+            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) {
@@ -148,52 +156,52 @@ async function doctorUnlockedAsync(projectRoot, options = {}) {
             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;
+    const toolchain = (0, toolchain_1.resolveHarmonyToolchain)();
+    let sdk;
     if (toolchain.sdkHome) {
-        sdkCheck = check('harmony-sdk', 'pass', `Complete Harmony SDK root was resolved at ${toolchain.sdkHome}.`);
+        sdk = 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.');
+        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(sdkCheck);
+    checks.push(sdk);
     const tools = [
-        ['ohpm', toolchain.ohpm, ['--version'], unavailableToolStatus],
-        ['hvigor-command', toolchain.hvigor, ['--version'], unavailableToolStatus],
+        ['ohpm', toolchain.ohpm, ['--version'], unavailable],
+        ['hvigor-command', toolchain.hvigor, ['--version'], unavailable],
     ];
     if (options.requireDeviceTools !== false) {
-        tools.unshift(['hdc', toolchain.hdc, ['-v'], unavailableToolStatus]);
+        tools.unshift(['hdc', toolchain.hdc, ['-v'], unavailable]);
     }
-    for (const [id, tool, versionArgs, unavailableStatus] of tools) {
+    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, ...versionArgs], {
+            const result = await (0, process_1.spawnAsync)(tool.command, [...tool.args, ...args], {
                 capture: true,
-                cwd: projectRoot,
+                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, unavailableStatus, `${command} is unavailable or unhealthy; HAP build cannot be verified.`));
+                : check(id, status, `${command} is unavailable or unhealthy; HAP build cannot be verified.`));
         }
         catch {
-            checks.push(check(id, unavailableStatus, `${command} is unavailable; generation remains available.`));
+            checks.push(check(id, status, `${command} is unavailable; generation remains available.`));
         }
     }
     if (options.validateGeneratedProject !== false) {
         try {
-            const plan = await (0, tools_1.resolveHarmonyBuildPlanIfPresentAsync)(projectRoot);
+            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', 'Generated root and module Hvigor files are required.'));
+                    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, native_project_1.isRnohAutolinkingDisabled)(content)
+                    checks.push((0, internal_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.'));
+                        : check('hvigor-autolinking', 'error', 'The module Hvigor file must disable duplicate RNOH autolinking.'));
                 }
             }
         }
@@ -204,11 +212,11 @@ async function doctorUnlockedAsync(projectRoot, options = {}) {
     return {
         checks,
         ok: checks.every(item => item.status !== 'error'),
-        projectRoot,
+        projectRoot: root,
     };
 }
-async function doctorAsync(projectRoot, options = {}) {
-    return (0, projectLock_1.withHarmonyProjectLockAsync)(projectRoot, 'doctor', () => doctorUnlockedAsync(projectRoot, options));
+async function doctorAsync(root, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(root, 'doctor', () => doctorUnlockedAsync(root, options));
 }
 function formatDoctor(result) {
     return result.checks.map((item) => {

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/exportEmbed/export.d.ts

@@ -12,5 +12,5 @@ export interface ExportTemporary {
     metroSourceMap: string;
     sourceMap: string;
 }
-declare function exportEmbedAsync(projectRoot: string, options?: ExportOptions): Promise<HarmonyExportManifest>;
-export { exportEmbedAsync, };
+declare function exportEmbedAsync(root: string, options?: ExportOptions): Promise<HarmonyExportManifest>;
+export { exportEmbedAsync };

package/build/exportEmbed/export.js

@@ -12,57 +12,56 @@ 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 project_1 = require("../native/project");
 const process_1 = require("../process");
 const expo_1 = require("../expo");
 const manifest_1 = require("./manifest");
-function createExpoExportEmbedArgs(projectRoot, entryFile, temporary, options = {}) {
+function createExpoExportEmbedArgs(root, entry, temp, options = {}) {
     return [
         'export:embed',
         '--platform', 'harmony',
-        '--entry-file', entryFile,
-        '--bundle-output', temporary.javascript,
-        '--assets-dest', temporary.assets,
+        '--entry-file', entry,
+        '--bundle-output', temp.javascript,
+        '--assets-dest', temp.assets,
         '--dev', 'false',
         '--minify', 'false',
-        '--sourcemap-output', temporary.metroSourceMap,
+        '--sourcemap-output', temp.metroSourceMap,
         '--sourcemap-sources-root', '.',
         '--unstable-transform-profile', 'hermes-stable',
         ...(options.resetCache ? ['--reset-cache=true'] : []),
-        projectRoot,
+        root,
     ];
 }
-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' });
+async function exportEmbedUnlockedAsync(root, options = {}) {
+    if (!options.skipDoctor) {
+        const doctor = await (0, doctor_1.doctorAsync)(root);
+        if (!doctor.ok) {
+            const checks = doctor.checks.filter(check => check.status === 'error').map(check => check.id);
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_DOCTOR', `Harmony doctor found blocking checks: ${checks.join(', ') || 'unknown'}.`, { operation: 'doctor' });
+        }
+    }
+    const plan = await (0, project_1.resolveHarmonyBuildPlanAsync)(root, { 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'),
+    const entry = (0, entry_1.resolveHarmonyEntryPoint)(root);
+    const directory = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'expo-harmony-export-'));
+    const temp = {
+        assets: node_path_1.default.join(directory, 'assets'),
+        bundle: node_path_1.default.join(directory, 'hermes_bundle.hbc'),
+        javascript: node_path_1.default.join(directory, 'index.js'),
+        metroSourceMap: node_path_1.default.join(directory, 'index.js.map'),
+        sourceMap: node_path_1.default.join(directory, 'hermes_bundle.hbc.map'),
     };
     try {
-        await node_fs_1.default.promises.mkdir(temporary.assets, { recursive: true });
-        const expo = (0, expo_1.resolveExpoCli)(projectRoot);
+        await node_fs_1.default.promises.mkdir(temp.assets, { recursive: true });
+        const expo = (0, expo_1.resolveExpoCli)(root);
         const result = await (0, process_1.spawnAsync)(process.execPath, [
             expo.cliPath,
-            ...createExpoExportEmbedArgs(projectRoot, entryFile, temporary, options),
+            ...createExpoExportEmbedArgs(root, entry, temp, options),
         ], {
             capture: true,
-            cwd: projectRoot,
+            cwd: root,
             env: {
                 ...process.env,
                 EXPO_METRO_TARGET: 'harmony',
@@ -81,45 +80,50 @@ async function exportEmbedUnlockedAsync(projectRoot, options = {}) {
         // 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'),
+                node_fs_1.default.promises.readFile(temp.javascript, 'utf8'),
+                node_fs_1.default.promises.readFile(temp.metroSourceMap, 'utf8'),
             ]);
-            const buildHermesBundleAsync = (0, expo_1.resolveExpoHermesBuilder)(projectRoot);
+            const buildHermesBundleAsync = (0, expo_1.resolveExpoHermesBuilder)(root);
             // 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 require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+            const runtime = node_path_1.default.dirname(require.resolve('@react-native-oh/react-native-harmony/package.json'));
+            const modules = node_path_1.default.join(directory, 'node_modules');
+            await node_fs_1.default.promises.mkdir(modules);
+            await node_fs_1.default.promises.symlink(runtime, node_path_1.default.join(modules, 'react-native'), process.platform === 'win32' ? 'junction' : 'dir');
             const output = await buildHermesBundleAsync({
                 code,
-                filename: entryFile,
+                filename: entry,
                 map,
                 minify: true,
-                projectRoot: temporaryRoot,
+                projectRoot: directory,
             });
             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),
+                node_fs_1.default.promises.writeFile(temp.bundle, output.hbc),
+                node_fs_1.default.promises.writeFile(temp.sourceMap, output.sourcemap),
             ]);
         }
         catch (cause) {
-            if (cause instanceof errors_1.HarmonyCliError)
-                throw cause;
+            if (cause instanceof errors_1.HarmonyCliError) {
+                throw new errors_1.HarmonyCliError(cause.code, cause.message, {
+                    cause,
+                    exitCode: cause.exitCode,
+                    operation: cause.operation,
+                });
+            }
             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);
+        const bytecode = await (0, manifest_1.assertHermesBundle)(temp.bundle);
+        await (0, manifest_1.assertSourceMap)(temp.sourceMap);
+        return await (0, manifest_1.publishExportAsync)(root, paths, temp, entry, bytecode);
     }
     finally {
-        await node_fs_1.default.promises.rm(temporaryRoot, { force: true, recursive: true });
+        await node_fs_1.default.promises.rm(directory, { force: true, recursive: true });
     }
 }
-async function exportEmbedAsync(projectRoot, options = {}) {
-    return (0, projectLock_1.withHarmonyProjectLockAsync)(projectRoot, 'export:embed', () => exportEmbedUnlockedAsync(projectRoot, options));
+async function exportEmbedAsync(root, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(root, 'export:embed', () => exportEmbedUnlockedAsync(root, options));
 }

package/build/exportEmbed/index.d.ts

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

package/build/exportEmbed/index.js

@@ -0,0 +1,19 @@
+"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.parseExportEmbedArgs, argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    const { exportEmbedAsync } = await import('./export.js');
+    const result = await exportEmbedAsync(root, options);
+    if (options.check)
+        io.log('Harmony export bundle, assets, and source map are valid.');
+    else
+        io.log(`Exported Hermes bytecode ${result.bundle.path} with ${result.assets.length} asset file(s).`);
+    return 0;
+};
+exports.command = command;

package/build/file.d.ts

@@ -6,4 +6,5 @@ declare function listFiles(root: string): Promise<string[]>;
 declare function atomicCopy(source: string, destination: string, root: string): Promise<void>;
 declare function atomicWriteJson(value: unknown, destination: string, root: string): Promise<void>;
 declare function removeEmptyParents(file: string, stop: string): Promise<void>;
-export { atomicCopy, atomicWriteJson, describeFile, listFiles, removeEmptyParents };
+declare function isNonEmptyRegularFile(file: string): boolean;
+export { atomicCopy, atomicWriteJson, describeFile, isNonEmptyRegularFile, listFiles, removeEmptyParents };

package/build/file.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.atomicCopy = atomicCopy;
 exports.atomicWriteJson = atomicWriteJson;
 exports.describeFile = describeFile;
+exports.isNonEmptyRegularFile = isNonEmptyRegularFile;
 exports.listFiles = listFiles;
 exports.removeEmptyParents = removeEmptyParents;
 const node_crypto_1 = __importDefault(require("node:crypto"));
@@ -66,24 +67,24 @@ async function ensureSafeParent(root, destination) {
 }
 async function atomicCopy(source, destination, root) {
     await ensureSafeParent(root, destination);
-    const temporary = node_path_1.default.join(node_path_1.default.dirname(destination), `.${node_path_1.default.basename(destination)}.expo-${node_crypto_1.default.randomUUID()}.tmp`);
+    const temp = node_path_1.default.join(node_path_1.default.dirname(destination), `.${node_path_1.default.basename(destination)}.expo-${node_crypto_1.default.randomUUID()}.tmp`);
     try {
-        await node_fs_1.default.promises.copyFile(source, temporary, node_fs_1.default.constants.COPYFILE_EXCL);
-        await node_fs_1.default.promises.rename(temporary, destination);
+        await node_fs_1.default.promises.copyFile(source, temp, node_fs_1.default.constants.COPYFILE_EXCL);
+        await node_fs_1.default.promises.rename(temp, destination);
     }
     finally {
-        await node_fs_1.default.promises.rm(temporary, { force: true });
+        await node_fs_1.default.promises.rm(temp, { force: true });
     }
 }
 async function atomicWriteJson(value, destination, root) {
     await ensureSafeParent(root, destination);
-    const temporary = node_path_1.default.join(node_path_1.default.dirname(destination), `.${node_path_1.default.basename(destination)}.expo-${node_crypto_1.default.randomUUID()}.tmp`);
+    const temp = node_path_1.default.join(node_path_1.default.dirname(destination), `.${node_path_1.default.basename(destination)}.expo-${node_crypto_1.default.randomUUID()}.tmp`);
     try {
-        await node_fs_1.default.promises.writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
-        await node_fs_1.default.promises.rename(temporary, destination);
+        await node_fs_1.default.promises.writeFile(temp, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
+        await node_fs_1.default.promises.rename(temp, destination);
     }
     finally {
-        await node_fs_1.default.promises.rm(temporary, { force: true });
+        await node_fs_1.default.promises.rm(temp, { force: true });
     }
 }
 async function removeEmptyParents(file, stop) {
@@ -98,3 +99,12 @@ async function removeEmptyParents(file, stop) {
         directory = node_path_1.default.dirname(directory);
     }
 }
+function isNonEmptyRegularFile(file) {
+    try {
+        const stat = node_fs_1.default.lstatSync(file);
+        return !stat.isSymbolicLink() && stat.isFile() && stat.size > 0;
+    }
+    catch {
+        return false;
+    }
+}

package/build/help.d.ts

@@ -0,0 +1 @@
+export declare const Help = "Usage: expo-harmony <command> [project] [options]\n\nCommands:\n  start                 Start Expo Metro for Harmony development\n  prebuild              Generate the Harmony native project with Expo CNG\n  prebuild --clean      Safely recreate the managed Harmony directory\n  prebuild --check      Compare generated desired state without project writes\n  build                 Build a HAP without selecting or contacting a device\n  doctor                Validate config, versions, Metro, RNOH, SDK, and signing\n  modules list          List native module candidates and their discovery source\n  modules inspect       Resolve Harmony metadata (--package narrows the result)\n  modules verify        Validate module config, registration conflicts and safe paths\n  export:embed          Export validated Hermes bytecode, assets, and a source map\n  run                   Build, install, and launch the Harmony app\n\nOptions:\n  --no-install          Skip dependency install (prebuild) or HAP install (run)\n  --npm|--yarn|--pnpm|--bun\n                        Select the package manager used by prebuild dependency install\n  --skip-dependency-update <packages>\n                        Preserve comma-separated dependency versions\n  --device <id-or-name> Select an HDC target or start a local emulator by name\n  --variant <mode>      Build debug or release (default: debug)\n  --no-bundler          Use an already-running Expo Metro server\n  --app-id <bundleName>\n                        Launch another installed app (requires --no-install when different)\n  --port <number>       Metro and device reverse port (default: 8081)\n  --sync                Re-run prebuild before building\n  --check               Validate an existing export without writing\n  --reset-cache         Reset Metro while exporting or starting\n  -c, --clear           Alias for --reset-cache (start)\n  -h, --help            Show this help\n";

package/build/help.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Help = void 0;
+exports.Help = `Usage: expo-harmony <command> [project] [options]
+
+Commands:
+  start                 Start Expo Metro for Harmony development
+  prebuild              Generate the Harmony native project with Expo CNG
+  prebuild --clean      Safely recreate the managed Harmony directory
+  prebuild --check      Compare generated desired state without project writes
+  build                 Build a HAP without selecting or contacting a device
+  doctor                Validate config, versions, Metro, RNOH, SDK, and signing
+  modules list          List native module candidates and their discovery source
+  modules inspect       Resolve Harmony metadata (--package narrows the result)
+  modules verify        Validate module config, registration conflicts and safe paths
+  export:embed          Export validated Hermes bytecode, assets, and a source map
+  run                   Build, install, and launch the Harmony app
+
+Options:
+  --no-install          Skip dependency install (prebuild) or HAP install (run)
+  --npm|--yarn|--pnpm|--bun
+                        Select the package manager used by prebuild dependency install
+  --skip-dependency-update <packages>
+                        Preserve comma-separated dependency versions
+  --device <id-or-name> Select an HDC target or start a local emulator by name
+  --variant <mode>      Build debug or release (default: debug)
+  --no-bundler          Use an already-running Expo Metro server
+  --app-id <bundleName>
+                        Launch another installed app (requires --no-install when different)
+  --port <number>       Metro and device reverse port (default: 8081)
+  --sync                Re-run prebuild before building
+  --check               Validate an existing export without writing
+  --reset-cache         Reset Metro while exporting or starting
+  -c, --clear           Alias for --reset-cache (start)
+  -h, --help            Show this help
+`;

package/build/index.d.ts

@@ -2,11 +2,13 @@ export { runAsync } from './cli';
 export { buildHarmonyAsync } from './buildHap/build';
 export type { HarmonyBuildOptions, HarmonyBuildResult } from './buildHap/build';
 export { exportEmbedAsync } from './exportEmbed/export';
-export { resolveHarmonyBuildPlanAsync, resolveHarmonyToolchain } from './tools';
-export { installHarmonyDependenciesAsync } from './run/install';
+export { resolveHarmonyBuildPlanAsync } from './native/project';
+export type { HarmonyBuildPlan, HarmonyBuildMode } from './native/types';
+export { resolveHarmonyToolchain } from './native/toolchain';
+export { installHarmonyDependenciesAsync } from './native/install';
 export { formatModulesResult, runModulesCommandAsync } from './modules/modules';
 export type { ModulesCommandResult } from './modules/modules';
-export { commitHarmonyNativeBuildCacheAsync, prepareHarmonyNativeBuildCacheAsync } from './run/cache';
+export { commitHarmonyNativeBuildCacheAsync, prepareHarmonyNativeBuildCacheAsync } from './native/cache';
 export { runHarmonyAsync } from './run/run';
 export type { HarmonyExportManifest } from './exportEmbed/manifest';
 export type { HarmonyRunOptions, HarmonyRunResult } from './run/run';