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

package/build/runtime/contract.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimeRequirementsAsync = resolveRuntimeRequirementsAsync;
+exports.publishRuntimeContractAsync = publishRuntimeContractAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const expo_modules_autolinking_1 = require("@expo-harmony/expo-modules-autolinking");
+const runtime_1 = require("@expo-harmony/expo-modules-autolinking/runtime");
+const json5_1 = __importDefault(require("json5"));
+const export_1 = require("../updates/export");
+const errors_1 = require("../errors");
+const file_1 = require("../file");
+const config_1 = require("./config");
+async function createRuntimeContractAsync(root, project, modules, metro) {
+    const resolution = metro ?? await (0, config_1.readMetroRuntimeAsync)(root);
+    if (!resolution?.fixedRuntime || resolution.harmonyPackage !== '@react-native-oh/react-native-harmony'
+        || typeof resolution.reactPackage !== 'string' || !resolution.reactPackage) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_CONFIG', 'Runtime contracts require withHarmonyConfig with the standard RNOH package and supported React resolution.', { operation: 'runtime-contract' });
+    }
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    const version = (name) => require(`${name}/package.json`).version;
+    const native = (0, node_module_1.createRequire)(require.resolve(resolution.harmonyPackage + '/package.json'));
+    const contract = {
+        schemaVersion: 1,
+        platform: 'harmony',
+        runtimeVersion: project.runtimeVersion,
+        development: true,
+        expo: version('expo'),
+        expoModulesCore: version('expo-modules-core'),
+        rnoh: native('./package.json').version,
+        react: version(resolution.reactPackage),
+        hermes: native('hermes-compiler/package.json').version,
+        engine: 'hermes-v1',
+        bundleFormat: 'js-source',
+        renderer: 'rnoh',
+        modules: (0, expo_modules_autolinking_1.createNativeModuleContracts)(modules),
+        config: project.native,
+    };
+    if (contract.rnoh !== '0.84.1' || contract.react !== '19.2.3' || contract.hermes !== '250829098.0.9'
+        || !contract.expo.startsWith('55.') || !modules.some(module => module.packageName === '@expo-harmony/expo-modules-core')) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_UNSUPPORTED', 'The fixed development runtime requires Expo SDK 55, Harmony Expo Modules Core, RNOH 0.84.1, React 19.2.3, and Hermes 250829098.0.9. Check the Metro React alias.', { operation: 'runtime-contract' });
+    }
+    const issues = (0, runtime_1.validateHarmonyRuntime)(contract);
+    if (issues.length > 0) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_CONFIG', issues.map(issue => issue.message).join('\n'), { operation: 'runtime-contract' });
+    }
+    return contract;
+}
+async function resolveRuntimeRequirementsAsync(root, metro) {
+    const result = await (0, expo_modules_autolinking_1.verifyModulesAsync)({ projectRoot: root });
+    if (!result.valid) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_MODULES', result.diagnostics.filter(item => item.severity === 'error').map(item => item.message).join('\n'), { operation: 'runtime-contract' });
+    }
+    const project = await (0, config_1.readProjectRuntimeAsync)(root);
+    return createRuntimeContractAsync(root, project, result.modules, metro);
+}
+async function publishRuntimeContractAsync(root, plan) {
+    const manifest = JSON.parse(await node_fs_1.default.promises.readFile(node_path_1.default.join(root, '.expo/harmony/autolinking.json'), 'utf8'));
+    if (manifest.schemaVersion !== 4 || manifest.platform !== 'harmony' || manifest.buildType !== plan.buildMode) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_BUILD', 'Runtime publication requires autolinking from this native build.', { operation: 'runtime-contract' });
+    }
+    const project = await (0, config_1.readProjectRuntimeAsync)(root);
+    const requirements = await createRuntimeContractAsync(root, project, manifest.modules);
+    if (!manifest.runtimeModules || JSON.stringify(requirements.modules) !== JSON.stringify(manifest.runtimeModules)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_BUILD', 'Native inputs changed or lack a runtime snapshot. Run autolinking/prebuild again before publishing capabilities.', { operation: 'runtime-contract' });
+    }
+    const read = (file) => json5_1.default.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+    const dependencies = read(plan.nativeInputs.manifest);
+    const declared = { ...dependencies.dependencies, ...dependencies.overrides };
+    const linked = (0, expo_modules_autolinking_1.ohpmDependenciesFromManifest)(manifest, { harmonyProjectPath: plan.harmonyRoot });
+    for (const [name, expected] of Object.entries(linked)) {
+        const actual = declared[name];
+        const target = node_fs_1.default.realpathSync(node_path_1.default.resolve(plan.harmonyRoot, expected));
+        if (typeof actual !== 'string' || !actual.startsWith('.')
+            || node_fs_1.default.realpathSync(node_path_1.default.resolve(plan.harmonyRoot, actual)) !== target) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_BUILD', `Native dependency ${name} does not use the HAR recorded by autolinking.`, { operation: 'runtime-contract' });
+        }
+    }
+    const directory = node_path_1.default.join(plan.harmonyRoot, 'oh_modules/@rnoh/react-native-openharmony');
+    const rnoh = read(node_path_1.default.join(directory, 'oh-package.json5'));
+    const hermes = read(node_path_1.default.join(directory, 'src/main/cpp/third-party/hermes/npm/hermes-compiler/package.json'));
+    if (rnoh.version !== requirements.rnoh || hermes.version !== requirements.hermes
+        || declared['@rnoh/react-native-openharmony'] !== requirements.rnoh
+        || process.env.HERMES_V1_ENABLED === 'false') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_BUILD', 'Runtime publication requires matching installed RNOH and Hermes v1.', { operation: 'runtime-contract' });
+    }
+    const native = (0, config_1.readNativeRuntime)(plan);
+    requirements.development = plan.buildMode === 'debug';
+    const contract = {
+        ...requirements,
+        runtimeVersion: await (0, config_1.resolveRuntimeVersionAsync)(root, project.config, native.app),
+        config: native.config,
+    };
+    (0, runtime_1.assertHarmonyCompatibility)(contract, requirements);
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    const file = node_path_1.default.join(plan.exportPaths.rawfileRoot, 'expo-harmony-runtime.json');
+    const source = require.resolve('@expo-harmony/expo-modules-autolinking/runtime-source');
+    const target = node_path_1.default.join(plan.moduleRoot, 'src/main/ets/generated/HarmonyRuntime.ts');
+    await (0, file_1.atomicCopy)(source, target, root);
+    await (0, file_1.atomicWriteJson)(contract, file, root);
+    await (0, file_1.atomicWriteJson)(contract, node_path_1.default.join(root, '.expo/harmony/runtime.json'), root);
+    await (0, export_1.publishUpdatesConfigurationAsync)(root, plan.exportPaths.rawfileRoot, project.config, contract.runtimeVersion);
+    return contract;
+}

package/build/runtime/fingerprint.d.ts

@@ -0,0 +1 @@
+export declare function fingerprintHarmonyAsync(root: string): Promise<import("@expo/fingerprint").Fingerprint>;

package/build/runtime/fingerprint.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprintHarmonyAsync = fingerprintHarmonyAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_module_1 = require("node:module");
+const fingerprint_1 = require("@expo/fingerprint");
+const expo_modules_autolinking_1 = require("@expo-harmony/expo-modules-autolinking");
+const errors_1 = require("../errors");
+async function fingerprintHarmonyAsync(root) {
+    const result = await (0, expo_modules_autolinking_1.verifyModulesAsync)({ projectRoot: root });
+    if (!result.valid)
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_FINGERPRINT', 'Build and verify Harmony native modules before calculating the runtime fingerprint.', { operation: 'fingerprint' });
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    const dependencies = (0, expo_modules_autolinking_1.createNativeModuleContracts)(result.modules);
+    const generated = [];
+    const previous = node_path_1.default.join(root, '.expo/harmony/export-manifest.json');
+    if (node_fs_1.default.existsSync(previous)) {
+        const manifest = JSON.parse(node_fs_1.default.readFileSync(previous, 'utf8'));
+        generated.push(...manifest.assets.map(asset => `**/harmony/**/src/main/resources/rawfile/${asset.path}`));
+    }
+    const sources = [{ type: 'contents', id: 'harmonyAutolinking', contents: JSON.stringify(dependencies), reasons: ['harmonyAutolinking'] }];
+    for (const name of ['@react-native-oh/react-native-harmony', '@expo-harmony/template', '@expo-harmony/config-plugins', '@expo-harmony/prebuild-config']) {
+        const file = require.resolve(name + '/package.json');
+        sources.push({ type: 'dir', filePath: node_path_1.default.relative(root, node_path_1.default.dirname(file)), reasons: ['harmonyNativeToolchain'] });
+    }
+    if (node_fs_1.default.existsSync(node_path_1.default.join(root, 'harmony')))
+        sources.push({ type: 'dir', filePath: 'harmony', reasons: ['harmonyNativeProject'] });
+    return (0, fingerprint_1.createFingerprintAsync)(root, {
+        platforms: [], extraSources: sources,
+        ignorePaths: [
+            ...generated,
+            '**/harmony/**/build/**', '**/harmony/**/.hvigor/**', '**/harmony/**/.cxx/**', '**/harmony/**/oh_modules/**',
+            '**/harmony/**/oh-package-lock.json5', '**/harmony/**/local.properties', '**/harmony/**/native-inputs.cmake',
+            '**/harmony/**/HarmonyRuntime.ts', '**/harmony/**/expo-harmony-runtime.json', '**/harmony/**/expo-updates/**',
+            '**/harmony/**/hermes_bundle.hbc', '**/harmony/**/hermes_bundle.hbc.*', '**/harmony/**/.expo-harmony/**',
+            '**/harmony/**/autolinking.cmake', '**/harmony/**/autolinking.cpp',
+            '**/harmony/**/generated/**', '**/*.har', '**/*.hap', '**/.git/**', '**/node_modules/**/node_modules/**',
+        ],
+    });
+}

package/build/runtime/index.d.ts

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

package/build/runtime/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const runtime_1 = require("@expo-harmony/expo-modules-autolinking/runtime");
+const args_1 = require("../args");
+const command_1 = require("../command");
+const errors_1 = require("../errors");
+const project_1 = require("../native/project");
+const contract_1 = require("./contract");
+const command = async (argv, io) => {
+    const args = (0, command_1.parseCommandArgs)((argv) => {
+        const { values, positionals } = (0, args_1.parseArgs)({
+            ...args_1.CommonOptions,
+            publish: { type: 'boolean' },
+            client: { type: 'string' },
+            variant: { type: 'string' },
+        }, argv);
+        if (positionals.length > 1 || (values.variant && !['debug', 'release'].includes(values.variant))
+            || (values.publish && values.client)) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', 'Use runtime [project] [--client file | --publish] [--variant debug|release].', { operation: 'parse-arguments' });
+        }
+        return { help: Boolean(values.help), project: positionals[0], ...values };
+    }, argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    if (options.publish) {
+        const plan = await (0, project_1.resolveHarmonyBuildPlanAsync)(root, { buildMode: options.variant });
+        await (0, contract_1.publishRuntimeContractAsync)(root, plan);
+        io.log('Published Harmony runtime capabilities and host validator.');
+    }
+    else {
+        const contract = await (0, contract_1.resolveRuntimeRequirementsAsync)(root);
+        if (options.client) {
+            const client = JSON.parse(await node_fs_1.default.promises.readFile(node_path_1.default.resolve(options.client), 'utf8'));
+            (0, runtime_1.assertHarmonyCompatibility)(client, contract);
+            io.log('Project is compatible with the fixed Harmony client.');
+        }
+        else {
+            io.log(JSON.stringify(contract, null, 2));
+        }
+    }
+    return 0;
+};
+exports.command = command;

package/build/start/index.d.ts

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

package/build/start/index.js

@@ -0,0 +1,38 @@
+"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.parseStartArgs, argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    const { startExpoMetroAsync } = await import('../run/metro.js');
+    const metro = await startExpoMetroAsync(root, {
+        ...options,
+        interactive: true,
+    });
+    try {
+        if (metro.development) {
+            io.log(`Harmony manifest: ${metro.development.manifestUrl}`);
+            io.log(`Harmony JS bundle: ${metro.development.bundleUrl}`);
+            io.log(`Harmony launch link: ${metro.development.launchLink}`);
+        }
+        if (metro.owner === 'existing') {
+            io.log(`Expo Metro is already running on port ${metro.port}.`);
+            if (options.resetCache) {
+                io.warn('Stop the existing Metro server and run this command again to reset its cache.');
+            }
+        }
+        else {
+            io.log('\n› Logs for your project will appear below. Press Ctrl+C to exit.');
+            await metro.waitAsync();
+        }
+        return 0;
+    }
+    finally {
+        await metro.stop();
+    }
+};
+exports.command = command;

package/build/start/options.d.ts

@@ -0,0 +1,9 @@
+declare function parseStartArgs(argv: string[]): {
+    help: boolean;
+    host: string;
+    port: number;
+    privateKeyPath: string;
+    project: string;
+    resetCache: boolean;
+};
+export { parseStartArgs };

package/build/start/options.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStartArgs = parseStartArgs;
+const args_1 = require("../args");
+const errors_1 = require("../errors");
+const StartOptions = {
+    ...args_1.CommonOptions,
+    'clear': { short: 'c', type: 'boolean' },
+    'host': { type: 'string' },
+    'port': { type: 'string' },
+    'private-key-path': { type: 'string' },
+    'reset-cache': { type: 'boolean' },
+};
+function parseStartArgs(argv) {
+    const { positionals, values } = (0, args_1.parseArgs)(StartOptions, argv);
+    if (positionals.length > 1) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unexpected start positional argument: ${positionals[1]}`, {
+            operation: 'parse-arguments',
+        });
+    }
+    const port = values.port === undefined ? 8081 : Number(values.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--port must be an integer between 1 and 65535.', {
+            operation: 'parse-arguments',
+        });
+    }
+    if (values.host !== undefined && !/^[A-Za-z0-9.-]+$/.test(values.host)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--host must be a hostname or IPv4 address without a port or scheme.', { operation: 'parse-arguments' });
+    }
+    return {
+        help: Boolean(values.help),
+        host: values.host,
+        port,
+        privateKeyPath: values['private-key-path'],
+        project: positionals[0],
+        resetCache: Boolean(values['reset-cache'] || values.clear),
+    };
+}

package/build/updates/export.d.ts

@@ -0,0 +1,14 @@
+import type { ExpoConfigWithHarmony } from '@expo-harmony/config-plugins';
+export interface UpdateAsset {
+    key: string;
+    hash: string;
+    contentType: string;
+    fileExtension: string;
+    embeddedAssetFilename: string;
+}
+export declare function publishUpdatesConfigurationAsync(root: string, directory: string, config: ExpoConfigWithHarmony, runtime: string): Promise<void>;
+export declare function publishEmbeddedUpdateAsync(root: string, paths: {
+    rawfileRoot: string;
+    bundle: string;
+    metadataRoot: string;
+}, assets: UpdateAsset[]): Promise<void>;

package/build/updates/export.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishUpdatesConfigurationAsync = publishUpdatesConfigurationAsync;
+exports.publishEmbeddedUpdateAsync = publishEmbeddedUpdateAsync;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const file_1 = require("../file");
+const errors_1 = require("../errors");
+const config_1 = require("../runtime/config");
+async function publishUpdatesConfigurationAsync(root, directory, config, runtime) {
+    const updates = { ...config.updates, runtimeVersion: runtime };
+    if (updates.url) {
+        const url = new URL(updates.url);
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_UPDATES_CONFIG', 'Updates URL must use HTTP or HTTPS.', { operation: 'updates-config' });
+    }
+    if (updates.codeSigningCertificate) {
+        const certificate = await promises_1.default.readFile(node_path_1.default.resolve(root, updates.codeSigningCertificate), 'utf8');
+        new node_crypto_1.default.X509Certificate(certificate);
+        updates.codeSigningCertificate = certificate;
+    }
+    await (0, file_1.atomicWriteJson)(updates, node_path_1.default.join(directory, 'expo-updates/config.json'), directory);
+}
+async function publishEmbeddedUpdateAsync(root, paths, assets) {
+    const project = await (0, config_1.readProjectRuntimeAsync)(root);
+    const bundle = await promises_1.default.readFile(paths.bundle);
+    const hash = node_crypto_1.default.createHash('sha256').update(Uint8Array.from(bundle)).digest('base64url');
+    const directory = node_path_1.default.join(paths.rawfileRoot, 'expo-updates');
+    const id = node_crypto_1.default.randomUUID();
+    const manifest = {
+        id, commitTime: Date.now(),
+        launchAsset: { packagerHash: `bundle-${id}`, hash, type: 'hbc',
+            embeddedAssetFilename: node_path_1.default.relative(paths.rawfileRoot, paths.bundle).split(node_path_1.default.sep).join('/') },
+        assets: [...new Map(assets.map(asset => [asset.key, asset])).values()].map(asset => ({
+            packagerHash: asset.key, hash: asset.hash, type: asset.fileExtension.replace(/^\./, ''),
+            embeddedAssetFilename: asset.embeddedAssetFilename,
+        })),
+    };
+    await publishUpdatesConfigurationAsync(root, paths.rawfileRoot, project.config, project.runtimeVersion);
+    await (0, file_1.atomicWriteJson)(manifest, node_path_1.default.join(directory, 'manifest.json'), paths.rawfileRoot);
+    await (0, file_1.atomicWriteJson)(manifest, node_path_1.default.join(paths.metadataRoot, 'update.json'), paths.metadataRoot);
+}

package/build/updates/index.d.ts

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

package/build/updates/index.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_module_1 = require("node:module");
+const config_1 = require("@expo/config");
+const node_path_1 = __importDefault(require("node:path"));
+const args_1 = require("../args");
+const command_1 = require("../command");
+const export_1 = require("../exportEmbed/export");
+const errors_1 = require("../errors");
+const file_1 = require("../file");
+const path_1 = require("../path");
+const expo_1 = require("../expo");
+const config_2 = require("../runtime/config");
+const command = async (argv, io) => {
+    const args = (0, command_1.parseCommandArgs)((values) => {
+        const { values: options, positionals } = (0, args_1.parseArgs)({ ...args_1.CommonOptions,
+            'output-dir': { type: 'string' }, 'asset-url': { type: 'string' },
+            'private-key-path': { type: 'string' }, 'reset-cache': { type: 'boolean' },
+        }, values);
+        if (positionals.length > 1)
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_ARGUMENTS', 'Expected at most one project directory.', { operation: 'export' });
+        return { ...options, project: positionals[0], help: Boolean(options.help) };
+    }, argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    const base = options['asset-url'];
+    if (!base || !['http:', 'https:'].includes(new URL(base).protocol)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_ARGUMENTS', 'OTA export requires --asset-url with the HTTP(S) directory that will host its assets.', { operation: 'export' });
+    }
+    const output = node_path_1.default.resolve(root, options['output-dir'] ?? 'dist');
+    const temporary = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'expo-harmony-update-'));
+    try {
+        await (0, export_1.exportEmbedAsync)(root, { outputDirectory: temporary, resetCache: options['reset-cache'] });
+        const embedded = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(temporary, 'update.json'), 'utf8'));
+        const project = await (0, config_2.readProjectRuntimeAsync)(root);
+        const { exp } = (0, config_1.getConfig)(root, { isPublicConfig: true });
+        const require = (0, node_module_1.createRequire)((0, expo_1.resolveExpoCli)(root).cliPath);
+        const upstream = (0, node_module_1.createRequire)(require.resolve('@expo/cli/package.json'));
+        const mime = upstream('mime-types');
+        const assets = [embedded.launchAsset, ...embedded.assets].map(asset => ({
+            key: asset.packagerHash, hash: asset.hash,
+            contentType: asset.type === 'hbc' ? 'application/javascript' : mime.lookup(asset.type) || 'application/octet-stream',
+            fileExtension: asset.type ? '.' + asset.type : '', embeddedAssetFilename: asset.embeddedAssetFilename,
+        }));
+        const manifest = {
+            id: embedded.id, createdAt: new Date(embedded.commitTime).toISOString(), runtimeVersion: project.runtimeVersion,
+            launchAsset: assets[0], assets: assets.slice(1), metadata: {},
+            extra: { expoClient: exp, eas: { projectId: exp.extra?.eas?.projectId },
+                scopeKey: exp.originalFullName ?? `@${exp.owner ?? 'anonymous'}/${exp.slug}` },
+        };
+        const metadata = [];
+        for (const asset of assets) {
+            const relative = `assets/${asset.hash}${asset.fileExtension}`;
+            await (0, file_1.atomicCopy)(node_path_1.default.join(temporary, 'embedded', (0, path_1.assertSafeRelative)(asset.embeddedAssetFilename, 'Embedded update asset')), node_path_1.default.join(output, relative), output);
+            Object.assign(asset, { url: new URL(relative, base.endsWith('/') ? base : base + '/').href });
+            delete asset.embeddedAssetFilename;
+            if (asset !== manifest.launchAsset)
+                metadata.push({ path: relative, ext: asset.fileExtension.replace(/^\./, '') });
+        }
+        await (0, file_1.atomicCopy)(node_path_1.default.join(temporary, 'hermes_bundle.hbc.map'), node_path_1.default.join(output, 'bundle.hbc.map'), output);
+        await (0, file_1.atomicWriteJson)({ version: 0, bundler: 'metro', fileMetadata: { harmony: {
+                    bundle: `assets/${manifest.launchAsset.hash}.hbc`, assets: metadata,
+                } } }, node_path_1.default.join(output, 'metadata.json'), output);
+        await (0, file_1.atomicWriteJson)(manifest, node_path_1.default.join(output, 'manifest.json'), output);
+        if (options['private-key-path']) {
+            const key = await promises_1.default.readFile(node_path_1.default.resolve(root, options['private-key-path']), 'utf8');
+            if (node_crypto_1.default.createPrivateKey(key).asymmetricKeyType !== 'rsa')
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_UPDATES_SIGNING', 'Expo Updates signing requires an RSA private key.', { operation: 'export' });
+            const body = await promises_1.default.readFile(node_path_1.default.join(output, 'manifest.json'));
+            const signature = node_crypto_1.default.sign('RSA-SHA256', Uint8Array.from(body), key).toString('base64');
+            const id = exp.updates?.codeSigningMetadata?.keyid ?? 'root';
+            const { serializeDictionary } = upstream('structured-headers');
+            await promises_1.default.writeFile(node_path_1.default.join(temporary, 'signature.txt'), serializeDictionary(new Map([
+                ['sig', [signature, new Map()]], ['keyid', [id, new Map()]], ['alg', ['rsa-v1_5-sha256', new Map()]],
+            ])));
+            await (0, file_1.atomicCopy)(node_path_1.default.join(temporary, 'signature.txt'), node_path_1.default.join(output, 'signature.txt'), output);
+        }
+        else {
+            await promises_1.default.rm(node_path_1.default.join(output, 'signature.txt'), { force: true });
+        }
+        io.log(`Exported Harmony update ${manifest.id} for runtime ${manifest.runtimeVersion} to ${output}.`);
+    }
+    finally {
+        await promises_1.default.rm(temporary, { recursive: true, force: true });
+    }
+    return 0;
+};
+exports.command = command;

package/build/upstream.d.ts

@@ -0,0 +1,9 @@
+declare const ProjectPackages: Readonly<{
+    expo: "expo";
+    expoAutolinking: "@expo-harmony/expo-modules-autolinking";
+    reactNative: "react-native";
+    rnohCli: "@react-native-oh/react-native-harmony-cli";
+    rnohRuntime: "@react-native-oh/react-native-harmony";
+}>;
+declare const RequiredProjectPackages: readonly ("@react-native-oh/react-native-harmony" | "@expo-harmony/expo-modules-autolinking" | "@react-native-oh/react-native-harmony-cli")[];
+export { ProjectPackages, RequiredProjectPackages, };

package/build/upstream.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredProjectPackages = exports.ProjectPackages = void 0;
+const ProjectPackages = Object.freeze({
+    expo: 'expo',
+    expoAutolinking: '@expo-harmony/expo-modules-autolinking',
+    reactNative: 'react-native',
+    rnohCli: '@react-native-oh/react-native-harmony-cli',
+    rnohRuntime: '@react-native-oh/react-native-harmony',
+});
+exports.ProjectPackages = ProjectPackages;
+const RequiredProjectPackages = Object.freeze([
+    ProjectPackages.rnohRuntime,
+    ProjectPackages.rnohCli,
+    ProjectPackages.expoAutolinking,
+]);
+exports.RequiredProjectPackages = RequiredProjectPackages;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo-harmony/cli",
-  "version": "55.0.26-harmony.1",
+  "version": "55.0.26-harmony.10",
   "keywords": [
     "react-native",
     "expo",
@@ -30,16 +30,32 @@
       "require": "./build/index.js",
       "default": "./build/index.js"
     },
-    "./bin/expo-harmony": "./build/bin/expo-harmony.js"
+    "./bin/expo-harmony": "./build/bin/expo-harmony.js",
+    "./native-build": {
+      "types": "./build/native/hvigor.d.ts",
+      "require": "./build/native/hvigor.js",
+      "default": "./build/native/hvigor.js"
+    },
+    "./internal/prebuild": {
+      "types": "./build/internal/prebuild.d.ts",
+      "require": "./build/internal/prebuild.js",
+      "default": "./build/internal/prebuild.js"
+    },
+    "./internal/development": {
+      "types": "./build/internal/development.d.ts",
+      "require": "./build/internal/development.js",
+      "default": "./build/internal/development.js"
+    }
   },
   "bin": {
     "expo-harmony": "build/bin/expo-harmony.js"
   },
   "dependencies": {
-    "@expo-harmony/config-plugins": "55.0.10-harmony.1",
-    "@expo-harmony/expo-modules-autolinking": "55.0.25-harmony.1",
-    "@expo-harmony/prebuild-config": "55.0.0-harmony.1",
+    "@expo-harmony/config-plugins": "55.0.10-harmony.4",
+    "@expo-harmony/expo-modules-autolinking": "55.0.25-harmony.4",
+    "@expo-harmony/prebuild-config": "55.0.0-harmony.8",
     "@expo/config": "55.0.17",
+    "@expo/fingerprint": "0.16.7",
     "cross-spawn": "^7.0.6",
     "json5": "2.2.3"
   },

package/src/bin/expo-harmony.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
 
-import { main } from '../cli';
+import { mainAsync } from '../cli';
 
-main();
+mainAsync();