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

package/build/run/run.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHarmonyAsync = runHarmonyAsync;
+exports.runHarmonySessionAsync = runHarmonySessionAsync;
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("@expo/config");
+const devices_1 = require("./devices");
+const errors_1 = require("../errors");
+const toolchain_1 = require("../native/toolchain");
+const metro_1 = require("./metro");
+const projectLock_1 = require("../projectLock");
+const build_1 = require("../native/build");
+const prepareProject_1 = require("../native/prepareProject");
+const log_1 = require("../log");
+const profile_1 = require("../profile");
+const BundleName = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*){2,}$/u;
+function resolveRunIdentity(plan, options) {
+    if (options.appId && !BundleName.test(options.appId)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--app-id must contain at least three valid dot-separated segments.', { operation: 'resolve-run' });
+    }
+    if (options.appId && !options.noInstall && options.appId !== plan.bundleName) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_APP_ID_MISMATCH', `--app-id can differ from the generated bundle name only with --no-install; expected ${plan.bundleName}.`, { operation: 'resolve-run' });
+    }
+    return {
+        abilityName: plan.abilityName,
+        bundleName: options.appId || plan.bundleName,
+    };
+}
+async function runHarmonyUnlockedAsync(root, options = {}) {
+    const settings = {
+        appId: options.appId,
+        device: options.device,
+        interactiveBundler: Boolean(options.interactiveBundler),
+        io: options.io || console,
+        noBundler: Boolean(options.noBundler),
+        noInstall: Boolean(options.noInstall),
+        port: options.port || 8081,
+        privateKeyPath: options.privateKeyPath,
+        resetCache: Boolean(options.resetCache),
+        sync: Boolean(options.sync),
+        variant: options.variant || 'debug',
+    };
+    const steps = {};
+    const plan = await (0, prepareProject_1.prepareNativeProjectAsync)(root, {
+        ...settings,
+        check: false,
+    }, steps);
+    const identity = resolveRunIdentity(plan, settings);
+    const tools = (0, toolchain_1.resolveHarmonyToolchain)();
+    (0, log_1.progress)(settings, 'Selecting a Harmony device or emulator');
+    const device = await (0, profile_1.timedAsync)(steps, 'device', () => (0, devices_1.selectDeviceAsync)(tools.hdc, settings.device, {
+        cwd: plan.harmonyRoot,
+        emulator: (0, toolchain_1.resolveHarmonyEmulator)(tools),
+        emulatorLogFile: node_path_1.default.join(root, '.expo', 'harmony', 'emulator.log'),
+        onProgress: message => (0, log_1.progress)(settings, message),
+    }));
+    const built = await (0, build_1.buildNativeAsync)(root, plan, tools, settings, steps);
+    let metro = {
+        owner: 'disabled',
+        port: settings.port,
+        stop: async () => { },
+        waitAsync: async () => { },
+    };
+    try {
+        if (settings.variant === 'debug' && (0, config_1.getConfig)(root).exp.updates?.useNativeDebug !== true) {
+            (0, log_1.progress)(settings, settings.noBundler
+                ? 'Connecting to the existing Expo Metro server'
+                : 'Starting Expo Metro');
+            metro = await (0, profile_1.timedAsync)(steps, 'metro', () => settings.noBundler
+                ? (0, metro_1.requireExistingMetroAsync)(settings.port)
+                : (0, metro_1.startExpoMetroAsync)(root, {
+                    interactive: settings.interactiveBundler,
+                    port: settings.port,
+                    privateKeyPath: settings.privateKeyPath,
+                    resetCache: settings.resetCache,
+                }));
+            await (0, profile_1.timedAsync)(steps, 'metroPort', () => (0, devices_1.configureMetroPortAsync)(tools.hdc, device, settings.port, { cwd: plan.harmonyRoot }));
+        }
+        else {
+            steps.metro = 0;
+            steps.metroPort = 0;
+        }
+        if (settings.noInstall) {
+            steps.install = 0;
+        }
+        else {
+            (0, log_1.progress)(settings, `Installing the HAP on ${device.id}`);
+            await (0, profile_1.timedAsync)(steps, 'install', () => (0, devices_1.installHapAsync)(tools.hdc, device, plan.expectedHap, { cwd: plan.harmonyRoot }));
+        }
+        (0, log_1.progress)(settings, `Launching ${identity.bundleName}`);
+        await (0, profile_1.timedAsync)(steps, 'launch', () => (0, devices_1.launchAppAsync)(tools.hdc, device, identity.bundleName, identity.abilityName, { cwd: plan.harmonyRoot }));
+        const result = {
+            bundleName: identity.bundleName,
+            device: {
+                id: device.id,
+                transport: device.transport,
+            },
+            ...built,
+            installed: !settings.noInstall,
+            launched: true,
+            metro: {
+                owner: metro.owner,
+                port: metro.port,
+            },
+            ok: true,
+            schemaVersion: 1,
+            steps,
+            variant: settings.variant,
+        };
+        return { metro, result };
+    }
+    catch (error) {
+        await metro.stop();
+        throw new errors_1.HarmonyCliError(error?.code || 'ERR_HARMONY_UNKNOWN', error?.message || 'Harmony run failed.', {
+            cause: error,
+            exitCode: error?.exitCode,
+            operation: error?.operation,
+        });
+    }
+}
+async function runHarmonySessionAsync(root, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(root, 'run', () => runHarmonyUnlockedAsync(root, options));
+}
+async function runHarmonyAsync(root, options = {}) {
+    const session = await runHarmonySessionAsync(root, options);
+    try {
+        return session.result;
+    }
+    finally {
+        await session.metro.stop();
+    }
+}

package/build/runtime/config.d.ts

@@ -0,0 +1,37 @@
+import { type ExpoConfigWithHarmony } from '@expo-harmony/config-plugins';
+import type { HarmonyBuildPlan } from '../native/types';
+export interface HarmonyMetroRuntime {
+    reactPackage: string;
+    harmonyPackage: string;
+    fixedRuntime: boolean;
+}
+export declare function resolveRuntimeVersionAsync(root: string, config: ExpoConfigWithHarmony, app: any): Promise<string>;
+export declare function readMetroRuntimeAsync(root: string): Promise<HarmonyMetroRuntime | undefined>;
+export declare function readNativeRuntime(plan: HarmonyBuildPlan): {
+    app: any;
+    config: {
+        nativeCompiler: string;
+        targetApiVersion: number | string;
+        compatibleApiVersion: number | string;
+        nativeLibFilterHash?: string;
+        permissions: string[];
+        querySchemes: string[];
+        backgroundModes: string[];
+        abiFilters: string[];
+    };
+};
+export declare function readProjectRuntimeAsync(root: string): Promise<{
+    config: ExpoConfigWithHarmony;
+    bundleName: string;
+    native: {
+        nativeCompiler: string;
+        targetApiVersion: number | string;
+        compatibleApiVersion: number | string;
+        nativeLibFilterHash?: string;
+        permissions: string[];
+        querySchemes: string[];
+        backgroundModes: string[];
+        abiFilters: string[];
+    };
+    runtimeVersion: string;
+}>;

package/build/runtime/config.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimeVersionAsync = resolveRuntimeVersionAsync;
+exports.readMetroRuntimeAsync = readMetroRuntimeAsync;
+exports.readNativeRuntime = readNativeRuntime;
+exports.readProjectRuntimeAsync = readProjectRuntimeAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_crypto_1 = require("node:crypto");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("@expo/config");
+const config_plugins_1 = require("@expo-harmony/config-plugins");
+const prebuild_config_1 = require("@expo-harmony/prebuild-config");
+const json5_1 = __importDefault(require("json5"));
+const fingerprint_1 = require("./fingerprint");
+const errors_1 = require("../errors");
+const project_1 = require("../native/project");
+async function resolveRuntimeVersionAsync(root, config, app) {
+    if (typeof config.runtimeVersion === 'object' && config.runtimeVersion?.policy === 'nativeVersion') {
+        if (typeof app?.versionName !== 'string' || !app.versionName
+            || !Number.isSafeInteger(app.versionCode) || app.versionCode < 1) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_CONFIG', 'The nativeVersion policy requires a Harmony versionName and a positive versionCode.', { operation: 'runtime-contract' });
+        }
+        return `${app.versionName}(${app.versionCode})`;
+    }
+    if (typeof config.runtimeVersion === 'object' && config.runtimeVersion?.policy === 'fingerprint') {
+        return (await (0, fingerprint_1.fingerprintHarmonyAsync)(root)).hash;
+    }
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    const expo = (0, node_module_1.createRequire)(require.resolve('expo/package.json'));
+    const { getRuntimeVersionAsync } = expo('@expo/config-plugins/build/utils/Updates');
+    const version = await getRuntimeVersionAsync(root, {
+        ...config,
+        runtimeVersion: config.runtimeVersion ?? { policy: 'sdkVersion' },
+    }, 'harmony');
+    if (typeof version !== 'string' || !version) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_CONFIG', 'Cannot resolve expo.runtimeVersion for Harmony.', { operation: 'runtime-contract' });
+    }
+    return version;
+}
+async function readMetroRuntimeAsync(root) {
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    const previous = process.env.EXPO_METRO_TARGET;
+    let config;
+    try {
+        process.env.EXPO_METRO_TARGET = 'harmony';
+        config = (await require('metro-config').resolveConfig(undefined, root)).config;
+    }
+    finally {
+        if (previous === undefined)
+            delete process.env.EXPO_METRO_TARGET;
+        else
+            process.env.EXPO_METRO_TARGET = previous;
+    }
+    return config?.resolver?.resolveRequest?.harmonyRuntime;
+}
+function onlyKeys(value, keys) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        && Object.keys(value).every(key => keys.includes(key));
+}
+function optionalStrings(value) {
+    return value === undefined || (Array.isArray(value) && value.every(item => typeof item === 'string' && item.length > 0));
+}
+function supportedReleaseOptions(modes) {
+    if (modes === undefined)
+        return true;
+    if (!Array.isArray(modes) || modes.length > 1)
+        return false;
+    return modes.every((mode) => {
+        if (!onlyKeys(mode, ['name', 'arkOptions', 'nativeLib']) || mode.name !== 'release')
+            return false;
+        if (mode.nativeLib !== undefined) {
+            const symbol = mode.nativeLib?.debugSymbol;
+            if (!onlyKeys(mode.nativeLib, ['debugSymbol']) || !onlyKeys(symbol, ['strip', 'exclude'])
+                || typeof symbol.strip !== 'boolean' || !optionalStrings(symbol.exclude))
+                return false;
+        }
+        if (mode.arkOptions !== undefined) {
+            const obfuscation = mode.arkOptions?.obfuscation;
+            const rules = obfuscation?.ruleOptions;
+            if (!onlyKeys(mode.arkOptions, ['obfuscation']) || !onlyKeys(obfuscation, ['ruleOptions'])
+                || !onlyKeys(rules, ['enable', 'files']) || typeof rules.enable !== 'boolean'
+                || !optionalStrings(rules.files))
+                return false;
+        }
+        return true;
+    });
+}
+function nativeLibFilterHash(filter) {
+    if (filter === undefined)
+        return undefined;
+    if (!onlyKeys(filter, ['excludes', 'pickFirsts', 'pickLasts', 'enableOverride'])
+        || !['excludes', 'pickFirsts', 'pickLasts'].every(key => optionalStrings(filter[key]))
+        || (filter.enableOverride !== undefined && typeof filter.enableOverride !== 'boolean')) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_CONFIG', 'Unsupported nativeLib.filter configuration.', { operation: 'runtime-contract' });
+    }
+    const values = {};
+    for (const key of ['excludes', 'pickFirsts', 'pickLasts']) {
+        if (filter[key]?.length)
+            values[key] = [...new Set(filter[key])].sort();
+    }
+    if (filter.enableOverride)
+        values['enableOverride'] = true;
+    return Object.keys(values).length ? (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(values)).digest('hex') : undefined;
+}
+function nativeConfig(profile, module, build, product, ability) {
+    const selected = profile?.app?.products?.find(item => item.name === product);
+    const entry = module?.abilities?.find(item => item.name === ability);
+    if (!selected || !entry || !build
+        || /(?:USE_HERMES|HERMES_V1_ENABLED)(?::BOOL)?=(?:OFF|FALSE|0)/i.test(build.buildOption?.externalNativeOptions?.arguments || '')
+        || Object.keys(selected.buildOption || {}).some(key => key !== 'nativeCompiler')
+        || profile.app.buildModeSet?.some(mode => mode.buildOption)
+        || !supportedReleaseOptions(build.buildOptionSet) || build.targets?.some(target => target.buildOption)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_RUNTIME_CONFIG', 'Runtime contracts require an existing Harmony product and ability, Hermes v1, and no per-target or per-mode overrides except release debugSymbol and ArkTS obfuscation rules.', { operation: 'runtime-contract' });
+    }
+    const hash = nativeLibFilterHash(build.buildOption?.nativeLib?.filter);
+    return {
+        nativeCompiler: selected.buildOption?.nativeCompiler,
+        targetApiVersion: (0, config_plugins_1.parseHarmonySdkVersion)(selected.targetSdkVersion, 'targetSdkVersion').api,
+        compatibleApiVersion: (0, config_plugins_1.parseHarmonySdkVersion)(selected.compatibleSdkVersion, 'compatibleSdkVersion').api,
+        ...(hash ? { nativeLibFilterHash: hash } : {}),
+        permissions: [...new Set((module.requestPermissions || []).map(item => item.name))].sort(),
+        querySchemes: [...new Set(module.querySchemes || [])].sort(),
+        backgroundModes: [...new Set(entry.backgroundModes || [])].sort(),
+        abiFilters: [...(build.buildOption?.externalNativeOptions?.abiFilters || [])].sort(),
+    };
+}
+function readNativeRuntime(plan) {
+    const read = (file) => json5_1.default.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+    const app = read(node_path_1.default.join(plan.harmonyRoot, 'AppScope/app.json5')).app;
+    const profile = read(plan.projectFiles.projectBuildProfile);
+    const module = read(plan.projectFiles.moduleJson).module;
+    const build = read(node_path_1.default.join(plan.moduleRoot, 'build-profile.json5'));
+    return { app, config: nativeConfig(profile, module, build, plan.productName, plan.abilityName) };
+}
+async function readProjectRuntimeAsync(root) {
+    const { exp } = (0, config_1.getConfig)(root, { skipSDKVersionRequirement: true, isModdedConfig: true });
+    const config = exp;
+    let native;
+    let bundle;
+    if (config.harmony) {
+        const settings = (0, config_plugins_1.normalizeHarmonyConfig)(config);
+        const evaluated = await (0, config_plugins_1.compileHarmonyModsAsync)((0, prebuild_config_1.withHarmonyPrebuildConfig)(config), {
+            projectRoot: root,
+            introspect: true,
+            ignoreExistingNativeFiles: true,
+        });
+        const results = evaluated._internal?.modResults?.harmony;
+        native = {
+            app: results?.appJson?.app,
+            config: nativeConfig(results?.projectBuildProfile, results?.moduleJson?.module, results?.entryBuildProfile, settings.productName, settings.abilityName),
+        };
+        bundle = settings.bundleName;
+    }
+    else {
+        const plan = await (0, project_1.resolveHarmonyBuildPlanAsync)(root);
+        native = readNativeRuntime(plan);
+        bundle = plan.bundleName;
+    }
+    return {
+        config,
+        bundleName: bundle,
+        native: native.config,
+        runtimeVersion: await resolveRuntimeVersionAsync(root, config, native.app),
+    };
+}

package/build/runtime/contract.d.ts

@@ -0,0 +1,5 @@
+import { type HarmonyRuntimeContract } from '@expo-harmony/expo-modules-autolinking/runtime';
+import type { HarmonyBuildPlan } from '../native/types';
+import { type HarmonyMetroRuntime } from './config';
+export declare function resolveRuntimeRequirementsAsync(root: string, metro?: HarmonyMetroRuntime): Promise<HarmonyRuntimeContract>;
+export declare function publishRuntimeContractAsync(root: string, plan: HarmonyBuildPlan): Promise<HarmonyRuntimeContract>;

package/build/runtime/contract.js

@@ -0,0 +1,109 @@
+"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: (0, runtime_1.harmonyRuntimeSchemaVersion)(project.native),
+        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,
+        schemaVersion: (0, runtime_1.harmonyRuntimeSchemaVersion)(native.config),
+        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,49 @@
+"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 config_1 = require("@expo/config");
+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 modules = (0, expo_modules_autolinking_1.createNativeModuleContracts)(result.modules);
+    const { exp } = (0, config_1.getConfig)(root, { skipSDKVersionRequirement: true, isModdedConfig: true });
+    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(modules), reasons: ['harmonyAutolinking'] }];
+    for (const name of ['@react-native-oh/react-native-harmony', '@expo-harmony/template', '@expo-harmony/config-plugins', '@expo-harmony/prebuild-config', '@expo-harmony/expo-build-properties']) {
+        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'] });
+    }
+    for (const file of exp._internal?.harmonyBuildProperties?.release?.obfuscation?.files ?? []) {
+        sources.push({ type: 'file', filePath: file, reasons: ['harmonyObfuscationRules'] });
+    }
+    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 };