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

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 {};

package/build/internal/export.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../errors");
+async function main() {
+    const [root, serialized, destination] = process.argv.slice(2);
+    const project = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    const expo = (0, node_module_1.createRequire)(project.resolve('expo/package.json'));
+    const require = (0, node_module_1.createRequire)(expo.resolve('@expo/cli/package.json'));
+    if (require('./package.json').version !== '55.0.32') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_UPSTREAM', 'Harmony asset export requires Expo CLI 55.0.32.', { operation: 'export' });
+    }
+    const options = JSON.parse(serialized);
+    require('./build/src/utils/nodeEnv').setNodeEnv('production');
+    require('./build/src/utils/nodeEnv').loadEnvFiles(root);
+    if (options.update) {
+        const directory = node_path_1.default.join(node_path_1.default.dirname(destination), 'export');
+        await require('./build/src/export/exportApp').exportAppAsync(root, {
+            platforms: ['harmony'], outputDir: directory, clear: options.resetCache,
+            dev: false, sourceMaps: true, minify: false, bytecode: false,
+        });
+        const metadata = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(directory, 'metadata.json'), 'utf8')).fileMetadata.harmony;
+        const mime = require('mime-types');
+        const assets = [];
+        for (const asset of metadata.assets) {
+            const source = node_path_1.default.join(directory, asset.path);
+            const data = await promises_1.default.readFile(source);
+            const key = node_path_1.default.basename(asset.path, node_path_1.default.extname(asset.path));
+            const relative = `assets/${key}.${asset.ext}`;
+            await promises_1.default.mkdir(node_path_1.default.join(options.assetsDest, 'assets'), { recursive: true });
+            await promises_1.default.copyFile(source, node_path_1.default.join(options.assetsDest, relative));
+            assets.push({ key, hash: node_crypto_1.default.createHash('sha256').update(Uint8Array.from(data)).digest('base64url'),
+                contentType: mime.lookup(asset.ext) || 'application/octet-stream', fileExtension: '.' + asset.ext,
+                embeddedAssetFilename: relative });
+        }
+        await require('@expo/metro/metro/shared/output/bundle').save({
+            code: await promises_1.default.readFile(node_path_1.default.join(directory, metadata.bundle), 'utf8'),
+            map: await promises_1.default.readFile(node_path_1.default.join(directory, metadata.bundle + '.map'), 'utf8'),
+        }, options, console.log);
+        await promises_1.default.writeFile(destination, JSON.stringify(assets));
+        return;
+    }
+    const { bundle, assets, files } = await require('./build/src/export/embed/exportEmbedAsync').exportEmbedBundleAndAssetsAsync(root, options);
+    const { getAssetLocalPath } = require('./build/src/export/metroAssetLocalPath');
+    const mime = require('mime-types');
+    const metadata = [];
+    for (const asset of assets) {
+        if (!Array.isArray(asset.fileHashes) || asset.fileHashes.length !== asset.files.length) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_ASSETS', 'Metro assets must include expo-asset fileHashes.', { operation: 'export' });
+        }
+        for (let index = 0; index < asset.files.length; index++) {
+            const data = await promises_1.default.readFile(asset.files[index]);
+            metadata.push({ key: asset.fileHashes[index], hash: node_crypto_1.default.createHash('sha256').update(Uint8Array.from(data)).digest('base64url'),
+                contentType: mime.lookup(asset.type) || 'application/octet-stream', fileExtension: '.' + asset.type,
+                embeddedAssetFilename: getAssetLocalPath(asset, { platform: 'harmony', scale: asset.scales[index] }) });
+        }
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(options.bundleOutput), { recursive: true });
+    await Promise.all([
+        require('@expo/metro/metro/shared/output/bundle').save(bundle, options, console.log),
+        require('./build/src/export/persistMetroAssets').persistMetroAssetsAsync(root, assets, { platform: 'harmony', outputDirectory: options.assetsDest }),
+    ]);
+    if (files.size > 0) {
+        const { copyPublicFolderAsync, getPublicFolderPath } = require('./build/src/export/publicFolder');
+        const { DOM_COMPONENTS_BUNDLE_DIR } = require('./build/src/start/server/middleware/DomComponentsMiddleware');
+        await require('./build/src/export/saveAssets').persistMetroFilesAsync(files, options.assetsDest);
+        await copyPublicFolderAsync(getPublicFolderPath(root), node_path_1.default.join(options.assetsDest, DOM_COMPONENTS_BUNDLE_DIR));
+    }
+    await promises_1.default.writeFile(destination, JSON.stringify(metadata));
+}
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/build/internal/prebuild.d.ts

@@ -0,0 +1,3 @@
+export { withGeneratedProjectAsync } from '../prebuild/check';
+export { assertSafeCleanTarget } from '../prebuild/clean';
+export { withHarmonyProjectLockAsync } from '../projectLock';

package/build/internal/prebuild.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withHarmonyProjectLockAsync = exports.assertSafeCleanTarget = exports.withGeneratedProjectAsync = void 0;
+var check_1 = require("../prebuild/check");
+Object.defineProperty(exports, "withGeneratedProjectAsync", { enumerable: true, get: function () { return check_1.withGeneratedProjectAsync; } });
+var clean_1 = require("../prebuild/clean");
+Object.defineProperty(exports, "assertSafeCleanTarget", { enumerable: true, get: function () { return clean_1.assertSafeCleanTarget; } });
+var projectLock_1 = require("../projectLock");
+Object.defineProperty(exports, "withHarmonyProjectLockAsync", { enumerable: true, get: function () { return projectLock_1.withHarmonyProjectLockAsync; } });

package/build/log.d.ts

@@ -0,0 +1,4 @@
+export type Log = Pick<Console, 'error' | 'log' | 'warn'>;
+export declare function progress(options: {
+    io?: Log;
+}, message: string): void;

package/build/log.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progress = progress;
+function progress(options, message) {
+    options.io?.log(`› ${message}`);
+}

package/build/modules/index.d.ts

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

package/build/modules/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.parseModulesArgs, argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    const { formatModulesResult, runModulesCommandAsync } = await import('./modules.js');
+    const result = await runModulesCommandAsync(root, options);
+    io.log(formatModulesResult(result));
+    return result.ok ? 0 : 1;
+};
+exports.command = command;