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

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

package/build/prebuild/check.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAsync = checkAsync;
+exports.withGeneratedProjectAsync = withGeneratedProjectAsync;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const internal_1 = require("@expo-harmony/prebuild-config/internal");
+const errors_1 = require("../errors");
+const path_1 = require("../path");
+const process_1 = require("../process");
+const projectLock_1 = require("../projectLock");
+const toolchain_1 = require("../native/toolchain");
+const project_1 = require("../native/project");
+const expo_1 = require("../expo");
+const template_1 = require("./template");
+const IgnoredDirectories = new Set(['.expo', '.git', '.hvigor', '.yarn', 'node_modules']);
+const GeneratedDirectories = new Set([
+    '.cxx',
+    '.git',
+    '.hvigor',
+    'build',
+    'node_modules',
+    'oh_modules',
+]);
+function mirrorRoot(temp, project) {
+    const absolute = node_path_1.default.resolve(project);
+    const parsed = node_path_1.default.parse(absolute);
+    const volume = parsed.root.replace(/[^A-Za-z0-9]+/gu, '') || 'root';
+    const segments = absolute.slice(parsed.root.length).split(node_path_1.default.sep).filter(Boolean);
+    return node_path_1.default.join(temp, 'filesystem', volume, ...segments);
+}
+async function linkModuleEntryAsync(source, target, entry) {
+    const directory = entry.isSymbolicLink()
+        ? (await node_fs_1.default.promises.stat(source)).isDirectory()
+        : entry.isDirectory();
+    if (process.platform === 'win32' && !directory) {
+        await node_fs_1.default.promises.copyFile(source, target);
+        return;
+    }
+    await node_fs_1.default.promises.symlink(node_path_1.default.resolve(source), target, directory ? process.platform === 'win32' ? 'junction' : 'dir' : 'file');
+}
+async function linkModulesAsync(source, target) {
+    await node_fs_1.default.promises.mkdir(target, { recursive: true });
+    for (const entry of await node_fs_1.default.promises.readdir(source, { withFileTypes: true })) {
+        const from = node_path_1.default.join(source, entry.name);
+        const to = node_path_1.default.join(target, entry.name);
+        if (entry.name.startsWith('@') && entry.isDirectory() && !entry.isSymbolicLink()) {
+            await node_fs_1.default.promises.mkdir(to);
+            for (const child of await node_fs_1.default.promises.readdir(from, { withFileTypes: true })) {
+                await linkModuleEntryAsync(node_path_1.default.join(from, child.name), node_path_1.default.join(to, child.name), child);
+            }
+            continue;
+        }
+        await linkModuleEntryAsync(from, to, entry);
+    }
+}
+function isAppLocalHarmonyPath(project, source) {
+    const segments = node_path_1.default.relative(project, source).split(node_path_1.default.sep);
+    return segments.length >= 3
+        && segments[0] === 'modules'
+        && segments[1] !== ''
+        && segments[2] === 'harmony';
+}
+function shouldCopyPrebuildCheckPath(project, source, plan) {
+    const relative = node_path_1.default.relative(project, source);
+    if (!relative)
+        return true;
+    const segments = relative.split(node_path_1.default.sep);
+    if (IgnoredDirectories.has(segments[0]))
+        return false;
+    const root = (0, path_1.isInside)(plan.harmonyRoot, source)
+        ? plan.harmonyRoot
+        : isAppLocalHarmonyPath(project, source)
+            ? node_path_1.default.join(project, ...segments.slice(0, 3))
+            : null;
+    if (root) {
+        const native = node_path_1.default.relative(root, source).split(node_path_1.default.sep);
+        if (GeneratedDirectories.has(native[0])
+            || (GeneratedDirectories.has(native[1])
+                && node_fs_1.default.existsSync(node_path_1.default.join(root, native[0], 'src/main/module.json5'))))
+            return false;
+    }
+    return source !== plan.exportPaths.bundle;
+}
+async function copyAsync(project, target, plan, temp = node_path_1.default.dirname(target)) {
+    await node_fs_1.default.promises.cp(project, target, {
+        recursive: true,
+        verbatimSymlinks: true,
+        filter: source => shouldCopyPrebuildCheckPath(project, source, plan),
+    });
+    const modules = node_path_1.default.join(project, 'node_modules');
+    if (!node_fs_1.default.existsSync(modules)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_DEPENDENCIES_MISSING', 'node_modules is required for --check.', {
+            operation: 'check',
+        });
+    }
+    // Link individual packages so dependency scanners retain paths inside the mirror.
+    await linkModulesAsync(modules, node_path_1.default.join(target, 'node_modules'));
+    await (0, internal_1.stageAsync)(project, target, temp);
+}
+async function withGeneratedProjectAsync(project, options, action) {
+    project = node_path_1.default.resolve(project);
+    const plan = await (0, project_1.resolveHarmonyBuildPlanAsync)(project);
+    const temp = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'expo-harmony-check-'));
+    const expected = mirrorRoot(temp, project);
+    let packed;
+    try {
+        await copyAsync(project, expected, plan, temp);
+        if (options.clean)
+            await node_fs_1.default.promises.rm(node_path_1.default.join(expected, 'harmony'), { recursive: true, force: true });
+        packed = await (0, template_1.packAsync)(project);
+        const expo = (0, expo_1.resolveExpoCli)(project);
+        const result = await (0, process_1.spawnAsync)(process.execPath, [
+            expo.cliPath,
+            'prebuild',
+            expected,
+            '--platform', 'harmony',
+            '--template', packed.tarball,
+            '--no-install',
+        ], {
+            capture: true,
+            cwd: expected,
+            env: {
+                ...(0, toolchain_1.createHarmonyToolchainEnv)(),
+                ...packed.env,
+                ...(options.buildType ? { EXPO_HARMONY_BUILD_TYPE: options.buildType } : {}),
+                EXPO_HARMONY_CHECK_MIRROR_ROOT: temp,
+                ...(options.skipPatches ? { EXPO_HARMONY_SKIP_PATCHES: '1' } : {}),
+            },
+            operation: 'check-prebuild',
+        });
+        if (result.code !== 0) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_DRIFT', `Isolated Expo prebuild failed:\n${result.stderr || result.stdout}`, { exitCode: result.code, operation: 'check-prebuild' });
+        }
+        const checksum = (0, node_crypto_1.createHash)('md5').update(Uint8Array.from(await node_fs_1.default.promises.readFile(packed.tarball))).digest('hex');
+        return await action(expected, checksum);
+    }
+    finally {
+        if (packed)
+            await packed.cleanup();
+        await node_fs_1.default.promises.rm(temp, { recursive: true, force: true });
+    }
+}
+async function checkAsync(project, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(project, 'prebuild-check', () => withGeneratedProjectAsync(project, options, expected => (0, internal_1.compareAsync)(project, expected)));
+}

package/build/prebuild/clean.d.ts

@@ -0,0 +1,2 @@
+declare function assertSafeCleanTarget(projectRoot: any): Promise<string>;
+export { assertSafeCleanTarget };

package/build/prebuild/clean.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.assertSafeCleanTarget = assertSafeCleanTarget;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const internal_1 = require("@expo-harmony/prebuild-config/internal");
+const errors_1 = require("../errors");
+const path_1 = require("../path");
+const project_1 = require("../native/project");
+async function assertSafeCleanTarget(projectRoot) {
+    const root = await node_fs_1.default.promises.realpath(projectRoot);
+    const plan = await (0, project_1.resolveHarmonyBuildPlanIfPresentAsync)(root);
+    const target = plan?.harmonyRoot ?? node_path_1.default.join(root, internal_1.HarmonyPlatformDirectory);
+    let stat;
+    try {
+        stat = await node_fs_1.default.promises.lstat(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return target;
+        throw new errors_1.HarmonyCliError(error.code || 'ERR_HARMONY_CLEAN_TARGET', error.message || `Cannot inspect the Harmony clean target: ${target}. Please delete it manually.`, { cause: error, exitCode: error.exitCode, operation: error.operation });
+    }
+    if (!plan || plan.workflow !== 'cng') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CLEAN_TARGET', `Refusing to clean ${target} because its CNG manifest is missing. Please delete it manually or run prebuild without --clean.`, { operation: 'clean' });
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CLEAN_TARGET', `Refusing to clean a non-directory or symlink: ${target}. Please delete it manually.`, {
+            operation: 'clean',
+        });
+    }
+    const real = await node_fs_1.default.promises.realpath(target);
+    if (real !== target || !(0, path_1.isInside)(root, real) || real === root || real === node_path_1.default.parse(real).root) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CLEAN_TARGET', `Unsafe Harmony clean target: ${real}. Please delete it manually.`, { operation: 'clean' });
+    }
+    const marker = plan.projectFiles.templateMarker;
+    let markerStat;
+    try {
+        markerStat = await node_fs_1.default.promises.lstat(marker);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CLEAN_TARGET', `Refusing to clean ${real} because its template marker cannot be inspected. Please delete it manually.`, { cause, operation: 'clean' });
+    }
+    if (!(0, path_1.isInside)(real, marker) || !markerStat.isFile() || markerStat.isSymbolicLink()) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CLEAN_TARGET', `Refusing to clean ${real} because its template marker is unsafe. Please delete it manually.`, { operation: 'clean' });
+    }
+    return real;
+}

package/build/prebuild/index.d.ts

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