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

package/build/exportEmbed/export.js

@@ -0,0 +1,124 @@
+"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 export_1 = require("../updates/export");
+const doctor_1 = require("../doctor/doctor");
+const entry_1 = require("../entry");
+const errors_1 = require("../errors");
+const projectLock_1 = require("../projectLock");
+const project_1 = require("../native/project");
+const process_1 = require("../process");
+const expo_1 = require("../expo");
+const manifest_1 = require("./manifest");
+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 = options.outputDirectory
+        ? {
+            rawfileRoot: node_path_1.default.join(options.outputDirectory, 'embedded'), bundle: node_path_1.default.join(options.outputDirectory, 'embedded/hermes_bundle.hbc'),
+            metadataRoot: options.outputDirectory, manifest: node_path_1.default.join(options.outputDirectory, 'export-manifest.json'),
+            sourceMap: node_path_1.default.join(options.outputDirectory, 'hermes_bundle.hbc.map'),
+        }
+        : (0, manifest_1.exportPaths)(plan);
+    if (options.check)
+        return await (0, manifest_1.validatePublishedExportAsync)(paths);
+    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'),
+        metadata: node_path_1.default.join(directory, 'assets.json'),
+        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(temp.assets, { recursive: true });
+        const result = await (0, process_1.spawnAsync)(process.execPath, [
+            node_path_1.default.resolve(__dirname, '../internal/export.js'), root,
+            JSON.stringify({ update: !!options.outputDirectory, platform: 'harmony', entryFile: entry, bundleOutput: temp.javascript, assetsDest: temp.assets,
+                dev: false, minify: false, sourcemapOutput: temp.metroSourceMap, sourcemapSourcesRoot: '.',
+                unstableTransformProfile: 'hermes-stable', resetCache: options.resetCache }), temp.metadata,
+        ], {
+            capture: true,
+            cwd: root,
+            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(temp.javascript, 'utf8'),
+                node_fs_1.default.promises.readFile(temp.metroSourceMap, 'utf8'),
+            ]);
+            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 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: entry,
+                map,
+                minify: true,
+                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(temp.bundle, output.hbc),
+                node_fs_1.default.promises.writeFile(temp.sourceMap, output.sourcemap),
+            ]);
+        }
+        catch (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)(temp.bundle);
+        await (0, manifest_1.assertSourceMap)(temp.sourceMap);
+        const manifest = await (0, manifest_1.publishExportAsync)(root, paths, temp, entry, bytecode);
+        await (0, export_1.publishEmbeddedUpdateAsync)(root, paths, JSON.parse(await node_fs_1.default.promises.readFile(temp.metadata, 'utf8')));
+        return manifest;
+    }
+    finally {
+        await node_fs_1.default.promises.rm(directory, { force: true, recursive: true });
+    }
+}
+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/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, };

package/build/exportEmbed/manifest.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HermesMagic = void 0;
+exports.assertHermesBundle = assertHermesBundle;
+exports.assertSourceMap = assertSourceMap;
+exports.exportPaths = exportPaths;
+exports.publishExportAsync = publishExportAsync;
+exports.validatePublishedExportAsync = validatePublishedExportAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../errors");
+const file_1 = require("../file");
+const path_1 = require("../path");
+const HermesMagic = Buffer.from('c61fbc03c103191f', 'hex');
+exports.HermesMagic = HermesMagic;
+const ManifestSchemaVersion = 1;
+function exportPaths(plan) {
+    return plan.exportPaths;
+}
+async function assertHermesBundle(file) {
+    let handle;
+    try {
+        handle = await node_fs_1.default.promises.open(file, 'r');
+        const header = Buffer.alloc(12);
+        const { bytesRead } = await handle.read(header, 0, header.length, 0);
+        const stat = await handle.stat();
+        if (bytesRead < header.length || stat.size <= header.length
+            || header.subarray(0, HermesMagic.length).toString('hex') !== HermesMagic.toString('hex')) {
+            throw new Error('Expo export did not produce non-empty Hermes bytecode.');
+        }
+        return { bytecodeVersion: header.readUInt32LE(8), size: stat.size };
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_INVALID_BUNDLE', 'The Harmony export output is not a valid Hermes bytecode bundle.', { cause, operation: 'validate-export' });
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function assertSourceMap(file) {
+    try {
+        const contents = await node_fs_1.default.promises.readFile(file, 'utf8');
+        const sourceMap = JSON.parse(contents);
+        const paths = JSON.stringify({ sourceRoot: sourceMap?.sourceRoot, sources: sourceMap?.sources });
+        const sourcePaths = [sourceMap?.sourceRoot, ...(sourceMap?.sources || [])]
+            .filter(value => typeof value === 'string');
+        const hasAbsoluteSource = sourcePaths.some(value => (node_path_1.default.posix.isAbsolute(value) || node_path_1.default.win32.isAbsolute(value) || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//u.test(value)));
+        if (sourceMap?.version !== 3 || !Array.isArray(sourceMap.sources)
+            || hasAbsoluteSource || paths.includes(node_os_1.default.homedir())) {
+            throw new Error('Invalid or host-specific source map.');
+        }
+        return await (0, file_1.describeFile)(file);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_INVALID_SOURCEMAP', 'Expo export did not produce a portable source map.', { cause, operation: 'validate-export' });
+    }
+}
+async function readPreviousManifest(file) {
+    try {
+        const manifest = JSON.parse(await node_fs_1.default.promises.readFile(file, 'utf8'));
+        if (manifest?.schemaVersion !== ManifestSchemaVersion || !Array.isArray(manifest.assets)) {
+            throw new Error('Unsupported export manifest schema.');
+        }
+        for (const asset of manifest.assets) {
+            (0, path_1.assertSafeRelative)(asset?.path, 'Previous export manifest');
+        }
+        return manifest;
+    }
+    catch (cause) {
+        if (cause.code === 'ENOENT')
+            return null;
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', 'Cannot read the previous Harmony export manifest.', { cause, operation: 'publish-export' });
+    }
+}
+async function publishExportAsync(projectRoot, paths, temporary, entryFile, bytecode) {
+    const previous = await readPreviousManifest(paths.manifest);
+    const previouslyOwned = new Set((previous?.assets || []).map(asset => asset.path));
+    const assetFiles = await (0, file_1.listFiles)(temporary.assets);
+    const assetOutputs = [];
+    for (const source of assetFiles) {
+        const relative = (0, path_1.toPosixPath)(node_path_1.default.relative(temporary.assets, source));
+        const nativeRelative = (0, path_1.assertSafeRelative)(relative, 'Expo asset output');
+        const destination = node_path_1.default.join(paths.rawfileRoot, nativeRelative);
+        if (await node_fs_1.default.promises.lstat(destination).catch(error => error.code === 'ENOENT' ? null : Promise.reject(error))) {
+            if (!previouslyOwned.has(relative)) {
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_COLLISION', `Expo asset output collides with an unmanaged raw resource: ${relative}.`, { operation: 'publish-export' });
+            }
+        }
+        assetOutputs.push({ descriptor: { path: relative, ...(await (0, file_1.describeFile)(source)) }, source });
+    }
+    assetOutputs.sort((left, right) => left.descriptor.path.localeCompare(right.descriptor.path, 'en'));
+    const assets = assetOutputs.map(output => output.descriptor);
+    const bundle = await (0, file_1.describeFile)(temporary.bundle);
+    const sourceMap = await (0, file_1.describeFile)(temporary.sourceMap);
+    const manifest = {
+        assets,
+        bundle: {
+            bytecodeVersion: bytecode.bytecodeVersion,
+            path: (0, path_1.toPosixPath)(node_path_1.default.relative(projectRoot, paths.bundle)),
+            ...bundle,
+        },
+        entryFile: (0, path_1.toPosixPath)(node_path_1.default.relative(projectRoot, entryFile)),
+        platform: 'harmony',
+        schemaVersion: ManifestSchemaVersion,
+        sourceMap: {
+            path: (0, path_1.toPosixPath)(node_path_1.default.relative(projectRoot, paths.sourceMap)),
+            ...sourceMap,
+        },
+        transformProfile: 'hermes-stable',
+    };
+    try {
+        await (0, file_1.atomicCopy)(temporary.bundle, paths.bundle, paths.rawfileRoot);
+        await (0, file_1.atomicCopy)(temporary.sourceMap, paths.sourceMap, paths.metadataRoot);
+        for (const output of assetOutputs) {
+            const relative = output.descriptor.path;
+            await (0, file_1.atomicCopy)(output.source, node_path_1.default.join(paths.rawfileRoot, (0, path_1.assertSafeRelative)(relative, 'Expo asset output')), paths.rawfileRoot);
+        }
+        await (0, file_1.atomicWriteJson)(manifest, paths.manifest, node_path_1.default.dirname(paths.manifest));
+        const nextOwned = new Set(assets.map(asset => asset.path));
+        for (const stale of previouslyOwned) {
+            if (nextOwned.has(stale))
+                continue;
+            const destination = node_path_1.default.join(paths.rawfileRoot, (0, path_1.assertSafeRelative)(stale, 'Previous export manifest'));
+            if (!(0, path_1.isInside)(paths.rawfileRoot, destination))
+                continue;
+            await node_fs_1.default.promises.rm(destination, { force: true });
+            await (0, file_1.removeEmptyParents)(destination, paths.rawfileRoot);
+        }
+    }
+    catch (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_PUBLISH', 'Cannot publish the validated Harmony bundle and assets.', { cause, operation: 'publish-export' });
+    }
+    return manifest;
+}
+async function validatePublishedExportAsync(paths) {
+    const manifest = await readPreviousManifest(paths.manifest);
+    if (!manifest) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', 'Harmony export manifest does not exist. Run expo-harmony export:embed first.', { operation: 'check-export' });
+    }
+    const bytecode = await assertHermesBundle(paths.bundle);
+    const sourceMap = await assertSourceMap(paths.sourceMap);
+    const expectedBundle = await (0, file_1.describeFile)(paths.bundle);
+    if (manifest.bundle?.sha256 !== expectedBundle.sha256
+        || manifest.bundle?.size !== expectedBundle.size
+        || manifest.bundle?.bytecodeVersion !== bytecode.bytecodeVersion
+        || manifest.sourceMap?.sha256 !== sourceMap.sha256
+        || manifest.sourceMap?.size !== sourceMap.size) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', 'Harmony bundle or source map differs from the export manifest.', { operation: 'check-export' });
+    }
+    for (const asset of manifest.assets) {
+        const file = node_path_1.default.join(paths.rawfileRoot, (0, path_1.assertSafeRelative)(asset.path, 'Export manifest'));
+        const actual = await (0, file_1.describeFile)(file).catch((cause) => {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', `Harmony export asset is missing or invalid: ${asset.path}.`, { cause, operation: 'check-export' });
+        });
+        if (actual.sha256 !== asset.sha256 || actual.size !== asset.size) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', `Harmony export asset differs from the manifest: ${asset.path}.`, { operation: 'check-export' });
+        }
+    }
+    return manifest;
+}

package/build/exportEmbed/options.d.ts

@@ -0,0 +1,7 @@
+declare function parseExportEmbedArgs(argv: string[]): {
+    check: boolean;
+    help: boolean;
+    project: string;
+    resetCache: boolean;
+};
+export { parseExportEmbedArgs };

package/build/exportEmbed/options.js

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

package/build/file.d.ts

@@ -0,0 +1,10 @@
+declare function describeFile(file: string): Promise<{
+    sha256: string;
+    size: number;
+}>;
+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>;
+declare function isNonEmptyRegularFile(file: string): boolean;
+export { atomicCopy, atomicWriteJson, describeFile, isNonEmptyRegularFile, listFiles, removeEmptyParents };

package/build/file.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const path_1 = require("./path");
+async function sha256File(file) {
+    return await new Promise((resolve, reject) => {
+        const hash = node_crypto_1.default.createHash('sha256');
+        const input = node_fs_1.default.createReadStream(file);
+        input.on('error', reject);
+        input.on('data', (chunk) => {
+            const bytes = typeof chunk === 'string' ? new TextEncoder().encode(chunk) : Uint8Array.from(chunk);
+            hash.update(bytes);
+        });
+        input.on('end', () => resolve(hash.digest('hex')));
+    });
+}
+async function describeFile(file) {
+    const stat = await node_fs_1.default.promises.stat(file);
+    if (!stat.isFile())
+        throw new Error(`Expected a regular file: ${file}`);
+    return { sha256: await sha256File(file), size: stat.size };
+}
+async function listFiles(root) {
+    const files = [];
+    async function visit(directory) {
+        const entries = await node_fs_1.default.promises.readdir(directory, { withFileTypes: true });
+        entries.sort((left, right) => left.name.localeCompare(right.name, 'en'));
+        for (const entry of entries) {
+            const file = node_path_1.default.join(directory, entry.name);
+            if (entry.isSymbolicLink())
+                throw new Error(`Asset output contains a symbolic link: ${entry.name}`);
+            if (entry.isDirectory())
+                await visit(file);
+            else if (entry.isFile())
+                files.push(file);
+            else
+                throw new Error(`Asset output contains an unsupported file: ${entry.name}`);
+        }
+    }
+    await visit(root);
+    return files;
+}
+async function ensureSafeParent(root, destination) {
+    if (!(0, path_1.isInside)(root, destination) || destination === root) {
+        throw new Error('Export destination escapes its owned root.');
+    }
+    await node_fs_1.default.promises.mkdir(root, { recursive: true });
+    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(destination), { recursive: true });
+    const [realRoot, realParent] = await Promise.all([
+        node_fs_1.default.promises.realpath(root),
+        node_fs_1.default.promises.realpath(node_path_1.default.dirname(destination)),
+    ]);
+    if (!(0, path_1.isInside)(realRoot, realParent)) {
+        throw new Error('Export destination follows a link outside its owned root.');
+    }
+}
+async function atomicCopy(source, destination, root) {
+    await ensureSafeParent(root, destination);
+    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, 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(temp, { force: true });
+    }
+}
+async function atomicWriteJson(value, destination, root) {
+    await ensureSafeParent(root, destination);
+    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(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(temp, { force: true });
+    }
+}
+async function removeEmptyParents(file, stop) {
+    let directory = node_path_1.default.dirname(file);
+    while (directory !== stop && (0, path_1.isInside)(stop, directory)) {
+        try {
+            await node_fs_1.default.promises.rmdir(directory);
+        }
+        catch {
+            return;
+        }
+        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  runtime               Describe project requirements; --client file checks compatibility\n  runtime --publish     Embed capabilities from prepared native build inputs\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                Export an OTA update, assets, metadata, and source map\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  --host <hostname>     Advertised HTTP LAN hostname (start)\n  --private-key-path <path>\n                        Sign development manifests using the configured Updates certificate\n  --port <number>       Metro and device reverse port (default: 8081)\n  --sync                Re-run prebuild before building\n  --output-dir <path>   OTA export directory (default: dist)\n  --asset-url <url>     HTTP(S) root hosting exported OTA assets\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,44 @@
+"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
+  runtime               Describe project requirements; --client file checks compatibility
+  runtime --publish     Embed capabilities from prepared native build inputs
+  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                Export an OTA update, assets, metadata, and source map
+  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)
+  --host <hostname>     Advertised HTTP LAN hostname (start)
+  --private-key-path <path>
+                        Sign development manifests using the configured Updates certificate
+  --port <number>       Metro and device reverse port (default: 8081)
+  --sync                Re-run prebuild before building
+  --output-dir <path>   OTA export directory (default: dist)
+  --asset-url <url>     HTTP(S) root hosting exported OTA assets
+  --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

@@ -0,0 +1,14 @@
+export { runAsync } from './cli';
+export { buildHarmonyAsync } from './buildHap/build';
+export type { HarmonyBuildOptions, HarmonyBuildResult } from './buildHap/build';
+export { exportEmbedAsync } from './exportEmbed/export';
+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 './native/cache';
+export { runHarmonyAsync } from './run/run';
+export type { HarmonyExportManifest } from './exportEmbed/manifest';
+export type { HarmonyRunOptions, HarmonyRunResult } from './run/run';

package/build/index.js

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

package/build/internal/development.d.ts

@@ -0,0 +1 @@
+export {};

package/build/internal/development.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_module_1 = require("node:module");
+const manifest_1 = require("../development/manifest");
+(0, manifest_1.installHarmonyManifest)(process.cwd());
+process.argv.splice(1, 1);
+const run = (0, node_module_1.createRequire)(__filename);
+run(process.argv[1]);

package/build/internal/export.d.ts

@@ -0,0 +1 @@
+export {};