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

package/build/native/hvigor.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareHarmonyNativeBuild = prepareHarmonyNativeBuild;
+exports.bundleHarmonyNativeBuild = bundleHarmonyNativeBuild;
+exports.publishHarmonyNativeRuntime = publishHarmonyNativeRuntime;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const native_inputs_1 = require("@expo-harmony/config-plugins/internal/native-inputs");
+const errors_1 = require("../errors");
+const toolchain_1 = require("./toolchain");
+function nodeExecutable() {
+    const candidates = process.env.EXPO_HARMONY_NODE
+        ? [process.env.EXPO_HARMONY_NODE]
+        : [
+            process.execPath,
+            ...(process.env.PATH || '').split(node_path_1.default.delimiter).filter(Boolean)
+                .map(directory => node_path_1.default.join(directory, process.platform === 'win32' ? 'node.exe' : 'node')),
+        ];
+    for (const candidate of new Set(candidates)) {
+        const result = (0, node_child_process_1.spawnSync)(candidate, ['-p', 'process.versions.node'], { encoding: 'utf8', timeout: 5_000 });
+        if (result.status === 0 && Number.parseInt(result.stdout, 10) >= 20)
+            return candidate;
+    }
+    throw new errors_1.HarmonyCliError('ERR_HARMONY_NODE', 'Harmony native builds require Node.js 20 or newer. Set EXPO_HARMONY_NODE to its executable.', { operation: 'native-build' });
+}
+function run(command, args, cwd) {
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        cwd,
+        env: { ...(0, toolchain_1.createHarmonyToolchainEnv)(), EXPO_HARMONY: '1', EXPO_METRO_TARGET: 'harmony', HERMES_V1_ENABLED: 'true' },
+        stdio: 'inherit',
+        timeout: 10 * 60_000,
+    });
+    if (result.error || result.status !== 0) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_NATIVE_BUILD', `Harmony build command failed: ${command} (${result.error?.message || result.status}).`, { cause: result.error, exitCode: result.status || 1, operation: 'native-build' });
+    }
+}
+// Hvigor configuration is synchronous; linking must finish before task execution.
+function prepareHarmonyNativeBuild(root, mode) {
+    const harmony = node_path_1.default.join(root, 'harmony');
+    if (process.env.EXPO_HARMONY_NATIVE_PREPARED !== '1') {
+        const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+        const manifest = node_path_1.default.resolve(node_path_1.default.dirname(require.resolve('@expo-harmony/expo-modules-autolinking')), '../package.json');
+        const bin = node_path_1.default.resolve(node_path_1.default.dirname(manifest), require(manifest).bin['expo-harmony-autolinking']);
+        run(nodeExecutable(), [bin, 'link', '--project-root', root, '--harmony-project-path', harmony, '--build-type', mode], root);
+        const { ohpm } = (0, toolchain_1.resolveHarmonyToolchain)();
+        run(ohpm.command, [...ohpm.args, 'install', '--all'], harmony);
+    }
+    publishHarmonyNativeRuntime(root, mode);
+    const { fingerprint } = (0, native_inputs_1.fingerprintHarmonyNativeInputsSync)({
+        projectRoot: root,
+        manifest: node_path_1.default.join(harmony, 'oh-package.json5'),
+        lockfile: node_path_1.default.join(harmony, 'oh-package-lock.json5'),
+    });
+    const file = node_path_1.default.join(harmony, '.hvigor/expo-harmony/native-inputs.cmake');
+    const content = `# Generated native dependency fingerprint.\nadd_compile_definitions(EXPO_HARMONY_NATIVE_INPUTS_SHA256_${fingerprint}=1)\n`;
+    if (node_fs_1.default.existsSync(file) && node_fs_1.default.readFileSync(file, 'utf8') === content)
+        return;
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+    const temp = `${file}.${node_crypto_1.default.randomUUID()}.tmp`;
+    try {
+        node_fs_1.default.writeFileSync(temp, content);
+        node_fs_1.default.renameSync(temp, file);
+    }
+    finally {
+        node_fs_1.default.rmSync(temp, { force: true });
+    }
+}
+function bundleHarmonyNativeBuild(root) {
+    if (process.env.EXPO_HARMONY_BUNDLE_PREBUILT === '1')
+        return;
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    run(nodeExecutable(), [require.resolve('@expo-harmony/cli/bin/expo-harmony'), 'export:embed', root], root);
+}
+function publishHarmonyNativeRuntime(root, mode) {
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(root, 'package.json'));
+    run(nodeExecutable(), [require.resolve('@expo-harmony/cli/bin/expo-harmony'), 'runtime', root, '--publish', '--variant', mode], root);
+}

package/build/native/install.d.ts

@@ -0,0 +1,5 @@
+import type { HarmonyBuildPlan } from './types';
+import type { HarmonyToolchain } from './toolchain';
+export declare function installHarmonyDependenciesAsync(plan: Pick<HarmonyBuildPlan, 'harmonyRoot'>, tools: HarmonyToolchain, options?: {
+    timeoutMs?: number;
+}): Promise<void>;

package/build/native/install.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installHarmonyDependenciesAsync = installHarmonyDependenciesAsync;
+const process_1 = require("../process");
+async function installHarmonyDependenciesAsync(plan, tools, options = {}) {
+    await (0, process_1.runCheckedAsync)(tools.ohpm.command, [...tools.ohpm.args, 'install', '--all'], {
+        code: 'ERR_HARMONY_OHPM_FAILED',
+        cwd: plan.harmonyRoot,
+        message: 'OHPM install',
+        operation: 'ohpm-install',
+        timeoutMs: options.timeoutMs || 5 * 60_000,
+    });
+}

package/build/native/prepareProject.d.ts

@@ -0,0 +1,11 @@
+import { type Log } from '../log';
+import type { HarmonyBuildPlan } from './types';
+interface PrepareProjectOptions {
+    io?: Log;
+    requireDeviceTools?: boolean;
+    check?: boolean;
+    sync: boolean;
+    variant: 'debug' | 'release';
+}
+declare function prepareNativeProjectAsync(root: string, options: PrepareProjectOptions, steps: Record<string, number>): Promise<HarmonyBuildPlan>;
+export { prepareNativeProjectAsync };

package/build/native/prepareProject.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareNativeProjectAsync = prepareNativeProjectAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const expo_modules_autolinking_1 = require("@expo-harmony/expo-modules-autolinking");
+const doctor_1 = require("../doctor/doctor");
+const errors_1 = require("../errors");
+const log_1 = require("../log");
+const profile_1 = require("../profile");
+const check_1 = require("../prebuild/check");
+const prebuild_1 = require("../prebuild/prebuild");
+const toolchain_1 = require("./toolchain");
+const project_1 = require("./project");
+async function prepareNativeProjectAsync(root, options, steps) {
+    const plan = await (0, profile_1.timedAsync)(steps, 'buildPlan', () => (0, project_1.resolveHarmonyBuildPlanIfPresentAsync)(root, {
+        buildMode: options.variant,
+    }));
+    const exists = Boolean(plan && node_fs_1.default.existsSync(plan.harmonyRoot));
+    if (plan?.workflow === 'bare' && options.sync) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_BARE_SYNC', '--sync regenerates CNG projects and cannot be used with a manually maintained bare project.', { operation: 'build' });
+    }
+    (0, log_1.progress)(options, 'Checking the Harmony project');
+    const doctor = await (0, profile_1.timedAsync)(steps, 'doctor', () => (0, doctor_1.doctorAsync)(root, {
+        requireBuildTools: true,
+        requireDeviceTools: options.requireDeviceTools,
+        validateGeneratedProject: exists,
+        validateModules: false,
+    }));
+    if (!doctor.ok) {
+        const checks = doctor.checks.filter(check => check.status === 'error').map(check => check.id);
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', `Harmony doctor found blocking checks: ${checks.join(', ') || 'unknown'}.`, { operation: 'doctor' });
+    }
+    if (plan?.workflow === 'bare') {
+        (0, log_1.progress)(options, 'Autolinking the bare Harmony project');
+        await (0, profile_1.timedAsync)(steps, 'autolinking', () => (0, expo_modules_autolinking_1.linkModulesAsync)({
+            projectRoot: root,
+            harmonyProjectPath: plan.harmonyRoot,
+            buildType: options.variant,
+            env: (0, toolchain_1.createHarmonyToolchainEnv)(),
+        }));
+        steps.prebuild = 0;
+        steps.cngCheck = 0;
+        return plan;
+    }
+    if (!exists || options.sync) {
+        (0, log_1.progress)(options, exists
+            ? 'Synchronizing the generated Harmony project'
+            : 'Generating the missing Harmony project');
+        await (0, profile_1.timedAsync)(steps, 'prebuild', () => (0, prebuild_1.prebuildParsedAsync)(root, [], { buildType: options.variant }));
+        steps.cngCheck = 0;
+        return (0, profile_1.timedAsync)(steps, 'buildPlan', () => (0, project_1.resolveHarmonyBuildPlanAsync)(root, { buildMode: options.variant }));
+    }
+    steps.prebuild = 0;
+    if (options.check === false) {
+        steps.cngCheck = 0;
+        return plan;
+    }
+    (0, log_1.progress)(options, 'Checking CNG ownership and drift');
+    const check = await (0, profile_1.timedAsync)(steps, 'cngCheck', () => (0, check_1.checkAsync)(root, { buildType: options.variant }));
+    if (!check.clean) {
+        const summary = check.changes.slice(0, 8).map(change => `${change.type}:${change.path}`).join(', ');
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_DRIFT', `Generated Harmony files differ from CNG desired state${summary ? ` (${summary})` : ''}. Run expo-harmony prebuild or retry with --sync.`, { operation: 'check' });
+    }
+    return plan;
+}

package/build/native/project.d.ts

@@ -0,0 +1,8 @@
+import type { HarmonyBuildPlan } from './types';
+declare function resolveHarmonyBuildPlanIfPresentAsync(root: string, options?: {
+    buildMode?: 'debug' | 'release';
+}): Promise<HarmonyBuildPlan | null>;
+declare function resolveHarmonyBuildPlanAsync(root: string, options?: {
+    buildMode?: 'debug' | 'release';
+}): Promise<HarmonyBuildPlan>;
+export { resolveHarmonyBuildPlanAsync, resolveHarmonyBuildPlanIfPresentAsync };

package/build/native/project.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHarmonyBuildPlanAsync = resolveHarmonyBuildPlanAsync;
+exports.resolveHarmonyBuildPlanIfPresentAsync = resolveHarmonyBuildPlanIfPresentAsync;
+const internal_1 = require("@expo-harmony/prebuild-config/internal");
+const errors_1 = require("../errors");
+const bare_1 = require("./bare");
+function createHarmonyBuildPlan(root, build, mode) {
+    const resolve = relative => (0, internal_1.resolveHarmonyBuildPath)(root, relative);
+    const variant = build.variants[mode];
+    return {
+        workflow: 'cng',
+        abilityName: build.identity.abilityName,
+        buildMode: mode,
+        bundleName: build.identity.bundleName,
+        expectedHap: resolve(variant.expectedHap),
+        exportPaths: Object.fromEntries(Object.entries(build.export).map(([name, relative]) => [name, resolve(relative)])),
+        harmonyRoot: resolve(build.harmonyRoot),
+        hvigorArgs: [...variant.hvigorArgs],
+        moduleName: build.identity.moduleName,
+        moduleRoot: resolve(build.moduleRoot),
+        nativeCache: {
+            invalidationRoots: build.nativeCache.invalidationRoots.map(resolve),
+            stateFile: resolve(build.nativeCache.stateFile),
+        },
+        nativeInputs: {
+            lockfile: resolve(build.nativeInputs.lockfile),
+            manifest: resolve(build.nativeInputs.manifest),
+        },
+        productName: build.identity.productName,
+        projectFiles: Object.fromEntries(Object.entries(build.projectFiles).map(([name, relative]) => [name, resolve(relative)])),
+        targetName: build.identity.targetName,
+    };
+}
+async function resolveHarmonyBuildPlanIfPresentAsync(root, options = {}) {
+    const mode = options.buildMode || 'debug';
+    if (!['debug', 'release'].includes(mode)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Harmony buildMode must be debug or release, received: ${mode}`, { operation: 'resolve-build' });
+    }
+    let manifest;
+    try {
+        manifest = await (0, internal_1.readManifestIfPresentAsync)(root);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError(cause.code || 'ERR_HARMONY_TEMPLATE_INVALID', `Cannot read the generated Harmony build descriptor: ${cause.message}`, { cause, operation: 'resolve-build' });
+    }
+    if (!manifest) {
+        return (0, bare_1.isBareHarmonyProject)(root) ? (0, bare_1.resolveBareHarmonyBuildPlan)(root, mode) : null;
+    }
+    return createHarmonyBuildPlan(root, manifest.build, mode);
+}
+async function resolveHarmonyBuildPlanAsync(root, options = {}) {
+    const plan = await resolveHarmonyBuildPlanIfPresentAsync(root, options);
+    if (!plan) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_DRIFT', 'Cannot read the generated Harmony build descriptor because the CNG manifest is missing.', { operation: 'resolve-build' });
+    }
+    return plan;
+}

package/build/native/toolchain.d.ts

@@ -0,0 +1,16 @@
+export interface HarmonyTool {
+    args: string[];
+    command: string;
+    source: 'deveco' | 'override' | 'path';
+}
+export interface HarmonyToolchain {
+    hdc: HarmonyTool;
+    hvigor: HarmonyTool;
+    ohpm: HarmonyTool;
+    sdkHome: string | null;
+    toolsRoot: string | null;
+}
+declare function resolveHarmonyToolchain(): HarmonyToolchain;
+declare function createHarmonyToolchainEnv(toolchain?: HarmonyToolchain): NodeJS.ProcessEnv;
+declare function resolveHarmonyEmulator(toolchain: HarmonyToolchain): HarmonyTool;
+export { createHarmonyToolchainEnv, resolveHarmonyEmulator, resolveHarmonyToolchain };

package/build/native/toolchain.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHarmonyToolchainEnv = createHarmonyToolchainEnv;
+exports.resolveHarmonyEmulator = resolveHarmonyEmulator;
+exports.resolveHarmonyToolchain = resolveHarmonyToolchain;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const tool_command_1 = require("@expo-harmony/expo-modules-autolinking/tool-command");
+function existingFile(candidates) {
+    return candidates.find(candidate => node_fs_1.default.existsSync(candidate)) || null;
+}
+const RequiredSdkComponents = Object.freeze([
+    'default/sdk-pkg.json',
+    'default/hms/ets/uni-package.json',
+    'default/hms/native/uni-package.json',
+    'default/hms/toolchains/uni-package.json',
+    'default/openharmony/ets/oh-uni-package.json',
+    'default/openharmony/native/oh-uni-package.json',
+    'default/openharmony/toolchains/oh-uni-package.json',
+]);
+function sdkRootsNear(seed) {
+    const roots = [];
+    let cursor = node_path_1.default.resolve(seed);
+    for (let depth = 0; depth < 6; depth += 1) {
+        const name = node_path_1.default.basename(cursor).toLowerCase();
+        if (name === 'default' && node_path_1.default.basename(node_path_1.default.dirname(cursor)).toLowerCase() === 'sdk') {
+            roots.push(node_path_1.default.dirname(cursor));
+        }
+        if (name === 'sdk')
+            roots.push(cursor);
+        roots.push(node_path_1.default.join(cursor, 'sdk'));
+        const parent = node_path_1.default.dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    return roots;
+}
+function resolveHarmonySdkRoot(env, platform) {
+    const seeds = [
+        env.DEVECO_SDK_HOME,
+        env.HARMONY_HOME,
+        env.OHOS_SDK_HOME,
+        env.HARMONY_HVIGORW,
+        env.HARMONY_OHPM,
+        env.HARMONY_NODE,
+        ...(env.PATH || '').split(node_path_1.default.delimiter).filter(Boolean),
+        ...(platform === 'darwin' ? ['/Applications/DevEco-Studio.app/Contents'] : []),
+    ].filter(Boolean);
+    const candidates = [...new Set(seeds.flatMap(sdkRootsNear))];
+    return candidates.find(root => RequiredSdkComponents.every(relative => node_fs_1.default.existsSync(node_path_1.default.join(root, ...relative.split('/'))))) || null;
+}
+function devEcoInstallRoots(sdkHome) {
+    const ancestors = [sdkHome, node_path_1.default.dirname(sdkHome), node_path_1.default.dirname(node_path_1.default.dirname(sdkHome))];
+    const sdkDirectory = ancestors.find(candidate => node_path_1.default.basename(candidate).toLowerCase() === 'sdk');
+    const roots = [
+        sdkDirectory && node_path_1.default.dirname(sdkDirectory),
+        node_path_1.default.dirname(sdkHome),
+        node_path_1.default.dirname(node_path_1.default.dirname(sdkHome)),
+    ].filter(Boolean);
+    return [...new Set(roots)];
+}
+function devEcoLayouts(sdkHome) {
+    return devEcoInstallRoots(sdkHome).flatMap(root => [
+        {
+            nodeRoot: node_path_1.default.join(root, 'tools', 'node'),
+            toolsRoot: node_path_1.default.join(root, 'tools'),
+        },
+        {
+            nodeRoot: node_path_1.default.join(root, 'tool', 'node'),
+            toolsRoot: root,
+        },
+    ]);
+}
+function devEcoNode(layout, platform, env) {
+    if (env.HARMONY_NODE)
+        return { command: env.HARMONY_NODE, source: 'override' };
+    const executable = platform === 'win32' ? 'node.exe' : 'node';
+    const command = existingFile([
+        node_path_1.default.join(layout.nodeRoot, 'bin', executable),
+        node_path_1.default.join(layout.nodeRoot, executable),
+    ]);
+    return command ? { command, source: 'deveco' } : null;
+}
+function resolveHarmonyToolchain() {
+    const env = process.env;
+    const platform = process.platform;
+    // Hvigor needs the complete SDK root containing default/, not default/ itself.
+    const sdkHome = resolveHarmonySdkRoot(env, platform);
+    const layouts = sdkHome ? devEcoLayouts(sdkHome) : [];
+    let ohpm;
+    if (env.HARMONY_OHPM) {
+        ohpm = { ...(0, tool_command_1.resolveHarmonyCommand)('ohpm', [], env), source: 'override' };
+    }
+    else {
+        const entry = layouts.map(layout => ({
+            node: devEcoNode(layout, platform, { ...env, HARMONY_NODE: env.HARMONY_OHPM_NODE || env.HARMONY_NODE }),
+            script: node_path_1.default.join(layout.toolsRoot, 'ohpm', 'bin', 'pm-cli.js'),
+        })).find(candidate => candidate.node && node_fs_1.default.existsSync(candidate.script));
+        const command = existingFile(layouts.map(layout => node_path_1.default.join(layout.toolsRoot, 'ohpm', 'bin', platform === 'win32' ? 'ohpm.bat' : 'ohpm')));
+        ohpm = entry
+            ? { args: [entry.script], command: entry.node.command, source: 'deveco' }
+            : command
+                ? { args: [], command, source: 'deveco' }
+                : { args: [], command: platform === 'win32' ? 'ohpm.bat' : 'ohpm', source: 'path' };
+    }
+    let hvigor;
+    if (env.HARMONY_HVIGORW) {
+        hvigor = { ...(0, tool_command_1.resolveHarmonyCommand)('hvigorw', [], env), source: 'override' };
+    }
+    else {
+        const entry = layouts.map(layout => ({
+            node: devEcoNode(layout, platform, { ...env, HARMONY_NODE: env.HARMONY_HVIGOR_NODE || env.HARMONY_NODE }),
+            script: node_path_1.default.join(layout.toolsRoot, 'hvigor', 'bin', 'hvigorw.js'),
+        })).find(candidate => candidate.node && node_fs_1.default.existsSync(candidate.script));
+        hvigor = entry
+            ? { args: [entry.script], command: entry.node.command, source: 'deveco' }
+            : { args: [], command: platform === 'win32' ? 'hvigorw.bat' : 'hvigorw', source: 'path' };
+    }
+    const toolsRoot = layouts.find(layout => (hvigor.args[0]?.startsWith(`${layout.toolsRoot}${node_path_1.default.sep}`)
+        || ohpm.args[0]?.startsWith(`${layout.toolsRoot}${node_path_1.default.sep}`)
+        || ohpm.command.startsWith(`${layout.toolsRoot}${node_path_1.default.sep}`)))?.toolsRoot || null;
+    let hdc;
+    if (env.HARMONY_HDC) {
+        hdc = { args: [], command: env.HARMONY_HDC, source: 'override' };
+    }
+    else {
+        const executable = platform === 'win32' ? 'hdc.exe' : 'hdc';
+        const sdkHdc = sdkHome && existingFile([
+            node_path_1.default.join(sdkHome, 'default', 'openharmony', 'toolchains', executable),
+            node_path_1.default.join(sdkHome, 'default', 'hms', 'toolchains', executable),
+        ]);
+        hdc = sdkHdc
+            ? { args: [], command: sdkHdc, source: 'deveco' }
+            : { args: [], command: executable, source: 'path' };
+    }
+    return { hdc, hvigor, ohpm, sdkHome, toolsRoot };
+}
+function createHarmonyToolchainEnv(toolchain = resolveHarmonyToolchain()) {
+    return {
+        ...process.env,
+        HARMONY_OHPM: toolchain.ohpm.args[0] || toolchain.ohpm.command,
+        HARMONY_OHPM_NODE: toolchain.ohpm.args.length > 0 ? toolchain.ohpm.command : undefined,
+        // Script-based tools must retain both their script and Node executable.
+        HARMONY_HVIGORW: toolchain.hvigor.args[0] || toolchain.hvigor.command,
+        HARMONY_HVIGOR_NODE: toolchain.hvigor.args.length > 0 ? toolchain.hvigor.command : undefined,
+        ...(toolchain.hvigor.args.length > 0
+            ? { HARMONY_NODE: toolchain.hvigor.command }
+            : toolchain.ohpm.args.length > 0 ? { HARMONY_NODE: toolchain.ohpm.command } : {}),
+        ...(toolchain.sdkHome && !process.env.DEVECO_SDK_HOME
+            ? { DEVECO_SDK_HOME: toolchain.sdkHome }
+            : {}),
+    };
+}
+function resolveHarmonyEmulator(toolchain) {
+    if (process.env.HARMONY_EMULATOR) {
+        return { args: [], command: process.env.HARMONY_EMULATOR, source: 'override' };
+    }
+    const executable = process.platform === 'win32' ? 'Emulator.exe' : 'Emulator';
+    const roots = [
+        toolchain.toolsRoot,
+        ...(toolchain.sdkHome ? devEcoLayouts(toolchain.sdkHome).map(layout => layout.toolsRoot) : []),
+        ...(process.platform === 'darwin' ? ['/Applications/DevEco-Studio.app/Contents/tools'] : []),
+    ].filter(Boolean);
+    const command = existingFile(roots.map(root => node_path_1.default.join(root, 'emulator', executable)));
+    return command
+        ? { args: [], command, source: 'deveco' }
+        : { args: [], command: executable, source: 'path' };
+}

package/build/native/types.d.ts

@@ -0,0 +1,47 @@
+export type HarmonyBuildMode = 'debug' | 'release';
+interface NativeBuildPlan {
+    abilityName: string;
+    buildMode: HarmonyBuildMode;
+    bundleName: string;
+    expectedHap: string;
+    exportPaths: {
+        bundle: string;
+        manifest: string;
+        metadataRoot: string;
+        rawfileRoot: string;
+        sourceMap: string;
+    };
+    harmonyRoot: string;
+    hvigorArgs: string[];
+    moduleName: string;
+    moduleRoot: string;
+    nativeCache: {
+        invalidationRoots: string[];
+        stateFile: string;
+    };
+    nativeInputs: {
+        lockfile: string;
+        manifest: string;
+    };
+    projectFiles: {
+        hvigorConfig: string;
+        moduleHvigor: string;
+        moduleJson: string;
+        projectBuildProfile: string;
+        rootHvigor: string;
+    };
+    productName: string;
+    targetName: string;
+}
+export interface BareHarmonyBuildPlan extends NativeBuildPlan {
+    workflow: 'bare';
+}
+export interface CngHarmonyBuildPlan extends NativeBuildPlan {
+    workflow: 'cng';
+    projectFiles: NativeBuildPlan['projectFiles'] & {
+        nativeInputsStamp: string;
+        templateMarker: string;
+    };
+}
+export type HarmonyBuildPlan = BareHarmonyBuildPlan | CngHarmonyBuildPlan;
+export {};

package/build/native/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/path.d.ts

@@ -0,0 +1,4 @@
+declare function isInside(root: string, target: string): boolean;
+declare function toPosixPath(value: string): string;
+declare function assertSafeRelative(relative: string, label: string): string;
+export { assertSafeRelative, isInside, toPosixPath };

package/build/path.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSafeRelative = assertSafeRelative;
+exports.isInside = isInside;
+exports.toPosixPath = toPosixPath;
+const node_path_1 = __importDefault(require("node:path"));
+function isInside(root, target) {
+    const relative = node_path_1.default.relative(root, target);
+    return relative === ''
+        || (relative !== '..' && !relative.startsWith(`..${node_path_1.default.sep}`) && !node_path_1.default.isAbsolute(relative));
+}
+function toPosixPath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}
+function assertSafeRelative(relative, label) {
+    const segments = typeof relative === 'string' ? relative.split('/') : [];
+    const native = segments.join(node_path_1.default.sep);
+    if (!relative || relative.includes('\\') || relative.includes('\0')
+        || segments.some(segment => !segment || segment === '.' || segment === '..')
+        || node_path_1.default.isAbsolute(native)) {
+        throw new Error(`${label} contains an unsafe path.`);
+    }
+    return native;
+}

package/build/prebuild/check.d.ts

@@ -0,0 +1,10 @@
+export type { Change as CheckChange } from '@expo-harmony/prebuild-config/internal';
+interface CheckOptions {
+    buildType?: 'debug' | 'release';
+}
+declare function withGeneratedProjectAsync<T>(project: string, options: CheckOptions & {
+    clean?: boolean;
+    skipPatches?: boolean;
+}, action: (expected: string, checksum: string) => Promise<T>): Promise<T>;
+declare function checkAsync(project: any, options?: CheckOptions): Promise<import("@expo-harmony/prebuild-config/internal").Result>;
+export { checkAsync, withGeneratedProjectAsync };