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

package/build/run/metro.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireExistingMetroAsync = requireExistingMetroAsync;
+exports.startExpoMetroAsync = startExpoMetroAsync;
+const node_http_1 = __importDefault(require("node:http"));
+const session_1 = require("../development/session");
+const errors_1 = require("../errors");
+const process_1 = require("../process");
+const expo_1 = require("../expo");
+function delay(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+function probeMetroAsync(port, options = {}) {
+    const timeoutMs = options.timeoutMs || 750;
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(value);
+        };
+        const request = node_http_1.default.get({
+            headers: { Accept: 'text/plain' },
+            host: options.host || '127.0.0.1',
+            path: '/status',
+            port,
+        }, (response) => {
+            let body = '';
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => {
+                if (body.length < 1_024)
+                    body += chunk;
+            });
+            response.on('end', () => finish(response.statusCode === 200 && body.trim() === 'packager-status:running'
+                ? 'metro'
+                : 'occupied'));
+        });
+        request.setTimeout(timeoutMs, () => {
+            request.destroy();
+            finish('occupied');
+        });
+        request.on('error', (error) => finish(error.code === 'ECONNREFUSED' || error.code === 'EHOSTUNREACH'
+            ? 'free'
+            : 'occupied'));
+    });
+}
+async function requireExistingMetroAsync(port) {
+    const status = await probeMetroAsync(port);
+    if (status === 'metro') {
+        return {
+            owner: 'existing',
+            port,
+            stop: async () => { },
+            waitAsync: async () => { },
+        };
+    }
+    const code = status === 'free' ? 'ERR_HARMONY_METRO_UNAVAILABLE' : 'ERR_HARMONY_METRO_PORT_IN_USE';
+    const message = status === 'free'
+        ? `No Metro server is running on port ${port}; start Expo Metro before using --no-bundler.`
+        : `Port ${port} is occupied by a process that is not a compatible Metro server.`;
+    throw new errors_1.HarmonyCliError(code, message, { operation: 'metro-probe' });
+}
+async function startExpoMetroAsync(projectRoot, options) {
+    const before = await probeMetroAsync(options.port);
+    if (before === 'metro') {
+        return {
+            development: await (0, session_1.readDevelopmentSessionAsync)(projectRoot, options.port, options.host),
+            owner: 'existing',
+            port: options.port,
+            stop: async () => { },
+            waitAsync: async () => { },
+        };
+    }
+    if (before === 'occupied') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_METRO_PORT_IN_USE', `Port ${options.port} is occupied by a process that is not a compatible Metro server.`, { operation: 'metro-probe' });
+    }
+    const expo = (0, expo_1.resolveExpoCli)(projectRoot);
+    const managed = (0, process_1.startManagedProcess)(process.execPath, [
+        require.resolve('../internal/development'),
+        expo.cliPath,
+        'start',
+        projectRoot,
+        '--dev-client',
+        '--port', String(options.port),
+        ...(options.privateKeyPath ? ['--private-key-path', options.privateKeyPath] : []),
+        ...(options.resetCache ? ['--clear'] : []),
+    ], {
+        cwd: projectRoot,
+        env: {
+            ...process.env,
+            EXPO_METRO_TARGET: 'harmony',
+            ...(options.host ? { REACT_NATIVE_PACKAGER_HOSTNAME: options.host } : {}),
+        },
+        operation: 'expo-metro',
+        outputLimit: 1024 * 1024,
+        stdio: options.interactive ? 'inherit' : 'pipe',
+    });
+    let exitResult = null;
+    let exitError = null;
+    managed.completion.then((result) => {
+        exitResult = result;
+    }, (error) => {
+        exitError = error;
+    });
+    const startedAt = Date.now();
+    const timeoutMs = options.readyTimeoutMs || 1800000;
+    try {
+        while (Date.now() - startedAt < timeoutMs) {
+            if (exitError instanceof errors_1.HarmonyCliError) {
+                throw new errors_1.HarmonyCliError(exitError.code, exitError.message, {
+                    cause: exitError,
+                    exitCode: exitError.exitCode,
+                    operation: exitError.operation,
+                });
+            }
+            if (exitError) {
+                const failure = exitError;
+                throw new errors_1.HarmonyCliError(failure.code || 'ERR_HARMONY_METRO_EXITED', failure.message || 'Expo Metro failed before becoming ready.', { cause: exitError, exitCode: failure.exitCode, operation: failure.operation });
+            }
+            if (exitResult) {
+                const diagnostics = (0, process_1.formatDiagnostics)(exitResult);
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_METRO_EXITED', `Expo Metro exited before becoming ready with code ${exitResult.code}.${diagnostics ? `\n${diagnostics}` : ''}`, { exitCode: exitResult.code || 1, operation: 'expo-metro' });
+            }
+            if (await probeMetroAsync(options.port) === 'metro') {
+                return {
+                    development: await (0, session_1.readDevelopmentSessionAsync)(projectRoot, options.port, options.host),
+                    owner: 'started',
+                    port: options.port,
+                    process: managed,
+                    stop: () => managed.stop(),
+                    async waitAsync() {
+                        const result = await managed.completion;
+                        if (managed.wasStopped())
+                            return;
+                        const interrupted = result.signal === 'SIGINT' || result.signal === 'SIGTERM';
+                        if (result.code === 0 || interrupted)
+                            return;
+                        const diagnostics = (0, process_1.formatDiagnostics)(result);
+                        throw new errors_1.HarmonyCliError('ERR_HARMONY_METRO_EXITED', `Expo Metro exited with code ${result.code}.${diagnostics ? `\n${diagnostics}` : ''}`, { exitCode: result.code || 1, operation: 'expo-metro' });
+                    },
+                };
+            }
+            await delay(150);
+        }
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_METRO_TIMEOUT', `Expo Metro did not become ready on port ${options.port} within ${timeoutMs}ms.`, { operation: 'expo-metro' });
+    }
+    catch (error) {
+        await managed.stop();
+        if (error instanceof errors_1.HarmonyCliError) {
+            throw new errors_1.HarmonyCliError(error.code, error.message, {
+                cause: error,
+                exitCode: error.exitCode,
+                operation: error.operation,
+            });
+        }
+        throw new errors_1.HarmonyCliError(error.code || 'ERR_HARMONY_METRO_EXITED', error.message || 'Expo Metro failed while waiting for the server to become ready.', { cause: error, exitCode: error.exitCode, operation: error.operation });
+    }
+}

package/build/run/options.d.ts

@@ -0,0 +1,14 @@
+declare function parseRunArgs(argv: string[]): {
+    appId: string;
+    device: string;
+    help: boolean;
+    noBundler: boolean;
+    noInstall: boolean;
+    port: number;
+    privateKeyPath: string;
+    project: string;
+    resetCache: boolean;
+    sync: boolean;
+    variant: "debug" | "release";
+};
+export { parseRunArgs };

package/build/run/options.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRunArgs = parseRunArgs;
+const errors_1 = require("../errors");
+const args_1 = require("../args");
+const RunOptions = {
+    ...args_1.CommonOptions,
+    'app-id': { type: 'string' },
+    'device': { type: 'string' },
+    'no-bundler': { type: 'boolean' },
+    'no-install': { type: 'boolean' },
+    'port': { type: 'string' },
+    'private-key-path': { type: 'string' },
+    'reset-cache': { type: 'boolean' },
+    'sync': { type: 'boolean' },
+    'variant': { type: 'string' },
+};
+function parseRunArgs(argv) {
+    const { positionals, values } = (0, args_1.parseArgs)(RunOptions, argv);
+    if (positionals.length > 1) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unexpected run positional argument: ${positionals[1]}`, {
+            operation: 'parse-arguments',
+        });
+    }
+    const variant = values.variant || 'debug';
+    if (variant !== 'debug' && variant !== 'release') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--variant must be debug or release.', {
+            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',
+        });
+    }
+    const appId = values['app-id'];
+    if (appId !== undefined && (!appId || appId.trim() !== appId || appId.includes('\0'))) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--app-id must be a non-empty Harmony bundle name.', {
+            operation: 'parse-arguments',
+        });
+    }
+    const device = values.device;
+    if (device !== undefined && (!device || device.trim() !== device || /[\0\r\n]/u.test(device))) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--device must be a non-empty HDC id or exact emulator name.', {
+            operation: 'parse-arguments',
+        });
+    }
+    return {
+        appId,
+        device,
+        help: Boolean(values.help),
+        noBundler: Boolean(values['no-bundler']),
+        noInstall: Boolean(values['no-install']),
+        port,
+        privateKeyPath: values['private-key-path'],
+        project: positionals[0],
+        resetCache: Boolean(values['reset-cache']),
+        sync: Boolean(values.sync),
+        variant: variant,
+    };
+}

package/build/run/run.d.ts

@@ -0,0 +1,46 @@
+import { type MetroSession } from './metro';
+import { type NativeBuildResult } from '../native/build';
+export interface HarmonyRunOptions {
+    appId?: string;
+    device?: string;
+    io?: Pick<Console, 'error' | 'log' | 'warn'>;
+    noBundler?: boolean;
+    noInstall?: boolean;
+    port?: number;
+    privateKeyPath?: string;
+    resetCache?: boolean;
+    sync?: boolean;
+    variant?: 'debug' | 'release';
+}
+export interface HarmonyRunResult extends NativeBuildResult {
+    bundleName: string;
+    device: {
+        id: string;
+        transport: string;
+    };
+    installed: boolean;
+    launched: true;
+    metro: {
+        owner: 'disabled' | 'existing' | 'started';
+        port: number;
+    };
+    ok: true;
+    schemaVersion: 1;
+    steps: Record<string, number>;
+    variant: 'debug' | 'release';
+}
+interface HarmonyRunSessionOptions extends HarmonyRunOptions {
+    interactiveBundler?: boolean;
+}
+interface HarmonyRunSession {
+    metro: MetroSession | {
+        owner: 'disabled';
+        port: number;
+        stop(): Promise<void>;
+        waitAsync(): Promise<void>;
+    };
+    result: HarmonyRunResult;
+}
+declare function runHarmonySessionAsync(root: string, options?: HarmonyRunSessionOptions): Promise<HarmonyRunSession>;
+declare function runHarmonyAsync(root: string, options?: HarmonyRunOptions): Promise<HarmonyRunResult>;
+export { runHarmonyAsync, runHarmonySessionAsync };

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,35 @@
+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;
+        compatibleApiVersion: number;
+        permissions: string[];
+        querySchemes: string[];
+        backgroundModes: string[];
+        abiFilters: string[];
+    };
+};
+export declare function readProjectRuntimeAsync(root: string): Promise<{
+    config: ExpoConfigWithHarmony;
+    bundleName: string;
+    native: {
+        nativeCompiler: string;
+        targetApiVersion: number;
+        compatibleApiVersion: number;
+        permissions: string[];
+        querySchemes: string[];
+        backgroundModes: string[];
+        abiFilters: string[];
+    };
+    runtimeVersion: string;
+}>;

package/build/runtime/config.js

@@ -0,0 +1,118 @@
+"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_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 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)
+        || build.buildOptionSet?.length || 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 native options without per-target or per-mode overrides.', { operation: 'runtime-contract' });
+    }
+    const api = (value) => typeof value === 'number' ? value : Number(/\((\d+)\)$/.exec(String(value))?.[1] ?? value);
+    return {
+        nativeCompiler: selected.buildOption?.nativeCompiler,
+        targetApiVersion: api(selected.targetSdkVersion),
+        compatibleApiVersion: api(selected.compatibleSdkVersion),
+        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>;