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

package/build/exportEmbed/manifest.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HermesMagic = void 0;
+exports.assertHermesBundle = assertHermesBundle;
+exports.assertSourceMap = assertSourceMap;
+exports.exportPaths = exportPaths;
+exports.publishExportAsync = publishExportAsync;
+exports.validatePublishedExportAsync = validatePublishedExportAsync;
+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 errors_1 = require("../errors");
+const file_1 = require("../file");
+const path_1 = require("../path");
+const HermesMagic = Buffer.from('c61fbc03c103191f', 'hex');
+exports.HermesMagic = HermesMagic;
+const ManifestSchemaVersion = 1;
+function exportPaths(plan) {
+    return plan.exportPaths;
+}
+async function assertHermesBundle(file) {
+    let handle;
+    try {
+        handle = await node_fs_1.default.promises.open(file, 'r');
+        const header = Buffer.alloc(12);
+        const { bytesRead } = await handle.read(header, 0, header.length, 0);
+        const stat = await handle.stat();
+        if (bytesRead < header.length || stat.size <= header.length
+            || header.subarray(0, HermesMagic.length).toString('hex') !== HermesMagic.toString('hex')) {
+            throw new Error('Expo export did not produce non-empty Hermes bytecode.');
+        }
+        return { bytecodeVersion: header.readUInt32LE(8), size: stat.size };
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_INVALID_BUNDLE', 'The Harmony export output is not a valid Hermes bytecode bundle.', { cause, operation: 'validate-export' });
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function assertSourceMap(file) {
+    try {
+        const contents = await node_fs_1.default.promises.readFile(file, 'utf8');
+        const sourceMap = JSON.parse(contents);
+        const paths = JSON.stringify({ sourceRoot: sourceMap?.sourceRoot, sources: sourceMap?.sources });
+        const sourcePaths = [sourceMap?.sourceRoot, ...(sourceMap?.sources || [])]
+            .filter(value => typeof value === 'string');
+        const hasAbsoluteSource = sourcePaths.some(value => (node_path_1.default.posix.isAbsolute(value) || node_path_1.default.win32.isAbsolute(value) || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//u.test(value)));
+        if (sourceMap?.version !== 3 || !Array.isArray(sourceMap.sources)
+            || hasAbsoluteSource || paths.includes(node_os_1.default.homedir())) {
+            throw new Error('Invalid or host-specific source map.');
+        }
+        return await (0, file_1.describeFile)(file);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_INVALID_SOURCEMAP', 'Expo export did not produce a portable source map.', { cause, operation: 'validate-export' });
+    }
+}
+async function readPreviousManifest(file) {
+    try {
+        const manifest = JSON.parse(await node_fs_1.default.promises.readFile(file, 'utf8'));
+        if (manifest?.schemaVersion !== ManifestSchemaVersion || !Array.isArray(manifest.assets)) {
+            throw new Error('Unsupported export manifest schema.');
+        }
+        for (const asset of manifest.assets) {
+            (0, path_1.assertSafeRelative)(asset?.path, 'Previous export manifest');
+        }
+        return manifest;
+    }
+    catch (cause) {
+        if (cause.code === 'ENOENT')
+            return null;
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', 'Cannot read the previous Harmony export manifest.', { cause, operation: 'publish-export' });
+    }
+}
+async function publishExportAsync(projectRoot, paths, temporary, entryFile, bytecode) {
+    const previous = await readPreviousManifest(paths.manifest);
+    const previouslyOwned = new Set((previous?.assets || []).map(asset => asset.path));
+    const assetFiles = await (0, file_1.listFiles)(temporary.assets);
+    const assetOutputs = [];
+    for (const source of assetFiles) {
+        const relative = (0, path_1.toPosixPath)(node_path_1.default.relative(temporary.assets, source));
+        const nativeRelative = (0, path_1.assertSafeRelative)(relative, 'Expo asset output');
+        const destination = node_path_1.default.join(paths.rawfileRoot, nativeRelative);
+        if (await node_fs_1.default.promises.lstat(destination).catch(error => error.code === 'ENOENT' ? null : Promise.reject(error))) {
+            if (!previouslyOwned.has(relative)) {
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_COLLISION', `Expo asset output collides with an unmanaged raw resource: ${relative}.`, { operation: 'publish-export' });
+            }
+        }
+        assetOutputs.push({ descriptor: { path: relative, ...(await (0, file_1.describeFile)(source)) }, source });
+    }
+    assetOutputs.sort((left, right) => left.descriptor.path.localeCompare(right.descriptor.path, 'en'));
+    const assets = assetOutputs.map(output => output.descriptor);
+    const bundle = await (0, file_1.describeFile)(temporary.bundle);
+    const sourceMap = await (0, file_1.describeFile)(temporary.sourceMap);
+    const manifest = {
+        assets,
+        bundle: {
+            bytecodeVersion: bytecode.bytecodeVersion,
+            path: (0, path_1.toPosixPath)(node_path_1.default.relative(projectRoot, paths.bundle)),
+            ...bundle,
+        },
+        entryFile: (0, path_1.toPosixPath)(node_path_1.default.relative(projectRoot, entryFile)),
+        platform: 'harmony',
+        schemaVersion: ManifestSchemaVersion,
+        sourceMap: {
+            path: (0, path_1.toPosixPath)(node_path_1.default.relative(projectRoot, paths.sourceMap)),
+            ...sourceMap,
+        },
+        transformProfile: 'hermes-stable',
+    };
+    try {
+        await (0, file_1.atomicCopy)(temporary.bundle, paths.bundle, paths.rawfileRoot);
+        await (0, file_1.atomicCopy)(temporary.sourceMap, paths.sourceMap, paths.metadataRoot);
+        for (const output of assetOutputs) {
+            const relative = output.descriptor.path;
+            await (0, file_1.atomicCopy)(output.source, node_path_1.default.join(paths.rawfileRoot, (0, path_1.assertSafeRelative)(relative, 'Expo asset output')), paths.rawfileRoot);
+        }
+        await (0, file_1.atomicWriteJson)(manifest, paths.manifest, node_path_1.default.dirname(paths.manifest));
+        const nextOwned = new Set(assets.map(asset => asset.path));
+        for (const stale of previouslyOwned) {
+            if (nextOwned.has(stale))
+                continue;
+            const destination = node_path_1.default.join(paths.rawfileRoot, (0, path_1.assertSafeRelative)(stale, 'Previous export manifest'));
+            if (!(0, path_1.isInside)(paths.rawfileRoot, destination))
+                continue;
+            await node_fs_1.default.promises.rm(destination, { force: true });
+            await (0, file_1.removeEmptyParents)(destination, paths.rawfileRoot);
+        }
+    }
+    catch (cause) {
+        if (cause instanceof errors_1.HarmonyCliError) {
+            throw new errors_1.HarmonyCliError(cause.code, cause.message, {
+                cause,
+                exitCode: cause.exitCode,
+                operation: cause.operation,
+            });
+        }
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_PUBLISH', 'Cannot publish the validated Harmony bundle and assets.', { cause, operation: 'publish-export' });
+    }
+    return manifest;
+}
+async function validatePublishedExportAsync(paths) {
+    const manifest = await readPreviousManifest(paths.manifest);
+    if (!manifest) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', 'Harmony export manifest does not exist. Run expo-harmony export:embed first.', { operation: 'check-export' });
+    }
+    const bytecode = await assertHermesBundle(paths.bundle);
+    const sourceMap = await assertSourceMap(paths.sourceMap);
+    const expectedBundle = await (0, file_1.describeFile)(paths.bundle);
+    if (manifest.bundle?.sha256 !== expectedBundle.sha256
+        || manifest.bundle?.size !== expectedBundle.size
+        || manifest.bundle?.bytecodeVersion !== bytecode.bytecodeVersion
+        || manifest.sourceMap?.sha256 !== sourceMap.sha256
+        || manifest.sourceMap?.size !== sourceMap.size) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', 'Harmony bundle or source map differs from the export manifest.', { operation: 'check-export' });
+    }
+    for (const asset of manifest.assets) {
+        const file = node_path_1.default.join(paths.rawfileRoot, (0, path_1.assertSafeRelative)(asset.path, 'Export manifest'));
+        const actual = await (0, file_1.describeFile)(file).catch((cause) => {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', `Harmony export asset is missing or invalid: ${asset.path}.`, { cause, operation: 'check-export' });
+        });
+        if (actual.sha256 !== asset.sha256 || actual.size !== asset.size) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_EXPORT_MANIFEST', `Harmony export asset differs from the manifest: ${asset.path}.`, { operation: 'check-export' });
+        }
+    }
+    return manifest;
+}

package/build/exportEmbed/options.d.ts

@@ -0,0 +1,7 @@
+declare function parseExportEmbedArgs(argv: string[]): {
+    check: boolean;
+    help: boolean;
+    project: string;
+    resetCache: boolean;
+};
+export { parseExportEmbedArgs };

package/build/exportEmbed/options.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExportEmbedArgs = parseExportEmbedArgs;
+const errors_1 = require("../errors");
+const args_1 = require("../args");
+const ExportEmbedOptions = {
+    ...args_1.CommonOptions,
+    'check': { type: 'boolean' },
+    'reset-cache': { type: 'boolean' },
+};
+function parseExportEmbedArgs(argv) {
+    const { positionals, values } = (0, args_1.parseArgs)(ExportEmbedOptions, argv);
+    if (positionals.length > 1) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unexpected export:embed positional argument: ${positionals[1]}`, { operation: 'parse-arguments' });
+    }
+    return {
+        check: Boolean(values.check),
+        help: Boolean(values.help),
+        project: positionals[0],
+        resetCache: Boolean(values['reset-cache']),
+    };
+}

package/build/file.d.ts

@@ -0,0 +1,9 @@
+declare function describeFile(file: string): Promise<{
+    sha256: string;
+    size: number;
+}>;
+declare function listFiles(root: string): Promise<string[]>;
+declare function atomicCopy(source: string, destination: string, root: string): Promise<void>;
+declare function atomicWriteJson(value: unknown, destination: string, root: string): Promise<void>;
+declare function removeEmptyParents(file: string, stop: string): Promise<void>;
+export { atomicCopy, atomicWriteJson, describeFile, listFiles, removeEmptyParents };

package/build/file.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.atomicCopy = atomicCopy;
+exports.atomicWriteJson = atomicWriteJson;
+exports.describeFile = describeFile;
+exports.listFiles = listFiles;
+exports.removeEmptyParents = removeEmptyParents;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const path_1 = require("./path");
+async function sha256File(file) {
+    return await new Promise((resolve, reject) => {
+        const hash = node_crypto_1.default.createHash('sha256');
+        const input = node_fs_1.default.createReadStream(file);
+        input.on('error', reject);
+        input.on('data', (chunk) => {
+            const bytes = typeof chunk === 'string' ? new TextEncoder().encode(chunk) : Uint8Array.from(chunk);
+            hash.update(bytes);
+        });
+        input.on('end', () => resolve(hash.digest('hex')));
+    });
+}
+async function describeFile(file) {
+    const stat = await node_fs_1.default.promises.stat(file);
+    if (!stat.isFile())
+        throw new Error(`Expected a regular file: ${file}`);
+    return { sha256: await sha256File(file), size: stat.size };
+}
+async function listFiles(root) {
+    const files = [];
+    async function visit(directory) {
+        const entries = await node_fs_1.default.promises.readdir(directory, { withFileTypes: true });
+        entries.sort((left, right) => left.name.localeCompare(right.name, 'en'));
+        for (const entry of entries) {
+            const file = node_path_1.default.join(directory, entry.name);
+            if (entry.isSymbolicLink())
+                throw new Error(`Asset output contains a symbolic link: ${entry.name}`);
+            if (entry.isDirectory())
+                await visit(file);
+            else if (entry.isFile())
+                files.push(file);
+            else
+                throw new Error(`Asset output contains an unsupported file: ${entry.name}`);
+        }
+    }
+    await visit(root);
+    return files;
+}
+async function ensureSafeParent(root, destination) {
+    if (!(0, path_1.isInside)(root, destination) || destination === root) {
+        throw new Error('Export destination escapes its owned root.');
+    }
+    await node_fs_1.default.promises.mkdir(root, { recursive: true });
+    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(destination), { recursive: true });
+    const [realRoot, realParent] = await Promise.all([
+        node_fs_1.default.promises.realpath(root),
+        node_fs_1.default.promises.realpath(node_path_1.default.dirname(destination)),
+    ]);
+    if (!(0, path_1.isInside)(realRoot, realParent)) {
+        throw new Error('Export destination follows a link outside its owned root.');
+    }
+}
+async function atomicCopy(source, destination, root) {
+    await ensureSafeParent(root, destination);
+    const temporary = node_path_1.default.join(node_path_1.default.dirname(destination), `.${node_path_1.default.basename(destination)}.expo-${node_crypto_1.default.randomUUID()}.tmp`);
+    try {
+        await node_fs_1.default.promises.copyFile(source, temporary, node_fs_1.default.constants.COPYFILE_EXCL);
+        await node_fs_1.default.promises.rename(temporary, destination);
+    }
+    finally {
+        await node_fs_1.default.promises.rm(temporary, { force: true });
+    }
+}
+async function atomicWriteJson(value, destination, root) {
+    await ensureSafeParent(root, destination);
+    const temporary = node_path_1.default.join(node_path_1.default.dirname(destination), `.${node_path_1.default.basename(destination)}.expo-${node_crypto_1.default.randomUUID()}.tmp`);
+    try {
+        await node_fs_1.default.promises.writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
+        await node_fs_1.default.promises.rename(temporary, destination);
+    }
+    finally {
+        await node_fs_1.default.promises.rm(temporary, { force: true });
+    }
+}
+async function removeEmptyParents(file, stop) {
+    let directory = node_path_1.default.dirname(file);
+    while (directory !== stop && (0, path_1.isInside)(stop, directory)) {
+        try {
+            await node_fs_1.default.promises.rmdir(directory);
+        }
+        catch {
+            return;
+        }
+        directory = node_path_1.default.dirname(directory);
+    }
+}

package/build/index.d.ts

@@ -0,0 +1,12 @@
+export { runAsync } from './cli';
+export { buildHarmonyAsync } from './buildHap/build';
+export type { HarmonyBuildOptions, HarmonyBuildResult } from './buildHap/build';
+export { exportEmbedAsync } from './exportEmbed/export';
+export { resolveHarmonyBuildPlanAsync, resolveHarmonyToolchain } from './tools';
+export { installHarmonyDependenciesAsync } from './run/install';
+export { formatModulesResult, runModulesCommandAsync } from './modules/modules';
+export type { ModulesCommandResult } from './modules/modules';
+export { commitHarmonyNativeBuildCacheAsync, prepareHarmonyNativeBuildCacheAsync } from './run/cache';
+export { runHarmonyAsync } from './run/run';
+export type { HarmonyExportManifest } from './exportEmbed/manifest';
+export type { HarmonyRunOptions, HarmonyRunResult } from './run/run';

package/build/modules/modules.d.ts

@@ -0,0 +1,42 @@
+import { type BuildType, type Diagnostic, type ModuleDescriptor, type ModuleSource } from '@expo-harmony/expo-modules-autolinking';
+import type { ModulesAction } from './options';
+interface ModulesCommandOptions {
+    action: ModulesAction;
+    nativeModulesDir?: string;
+    packageName?: string;
+    variant?: BuildType;
+}
+interface ListedModule {
+    packageName: string;
+    packageVersion: string;
+    source: ModuleSource;
+    supportsHarmony: boolean;
+}
+interface ModulesListResult {
+    action: 'list';
+    duplicates: ReadonlyArray<{
+        packageName: string;
+        revisions: ReadonlyArray<{
+            path: string;
+            version: string;
+        }>;
+    }>;
+    missingIncludes: ReadonlyArray<string>;
+    modules: ReadonlyArray<ListedModule>;
+    ok: boolean;
+}
+interface ModulesInspectResult {
+    action: 'inspect';
+    modules: ReadonlyArray<ModuleDescriptor>;
+    ok: boolean;
+}
+interface ModulesVerifyResult {
+    action: 'verify';
+    diagnostics: ReadonlyArray<Diagnostic>;
+    modules: ReadonlyArray<ModuleDescriptor>;
+    ok: boolean;
+}
+export type ModulesCommandResult = ModulesInspectResult | ModulesListResult | ModulesVerifyResult;
+declare function runModulesCommandAsync(projectRoot: string, options: ModulesCommandOptions): Promise<ModulesCommandResult>;
+declare function formatModulesResult(result: ModulesCommandResult): string;
+export { formatModulesResult, runModulesCommandAsync };

package/build/modules/modules.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatModulesResult = formatModulesResult;
+exports.runModulesCommandAsync = runModulesCommandAsync;
+const expo_modules_autolinking_1 = require("@expo-harmony/expo-modules-autolinking");
+const errors_1 = require("../errors");
+function apiOptions(projectRoot, options) {
+    return {
+        projectRoot,
+        platform: 'harmony',
+        ...(options.nativeModulesDir === undefined ? {} : { nativeModulesDir: options.nativeModulesDir }),
+        ...(options.variant === undefined ? {} : { buildType: options.variant }),
+    };
+}
+async function runModulesCommandAsync(projectRoot, options) {
+    const shared = apiOptions(projectRoot, options);
+    if (options.action === 'list') {
+        const result = await (0, expo_modules_autolinking_1.searchModulesAsync)(shared);
+        return {
+            action: 'list',
+            duplicates: result.duplicates,
+            missingIncludes: result.missingIncludes,
+            modules: result.modules.map(module => ({
+                packageName: module.packageName,
+                packageVersion: module.packageVersion,
+                source: module.source,
+                supportsHarmony: module.supportsHarmony,
+            })),
+            ok: result.missingIncludes.length === 0,
+        };
+    }
+    if (options.action === 'inspect') {
+        const modules = await (0, expo_modules_autolinking_1.resolveModulesAsync)(shared);
+        const selected = options.packageName === undefined
+            ? modules
+            : modules.filter(module => module.packageName === options.packageName);
+        if (options.packageName !== undefined && selected.length === 0) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_MODULE_NOT_FOUND', `Harmony module '${options.packageName}' was not discovered. Run 'expo-harmony modules list' to inspect candidates.`, { operation: 'modules-inspect' });
+        }
+        return { action: 'inspect', modules: selected, ok: true };
+    }
+    const result = await (0, expo_modules_autolinking_1.verifyModulesAsync)(shared);
+    return {
+        action: 'verify',
+        diagnostics: result.diagnostics,
+        modules: result.modules,
+        ok: result.valid,
+    };
+}
+function formatDiagnostic(diagnostic) {
+    const subject = diagnostic.packageName ? ` ${diagnostic.packageName}` : '';
+    return `${diagnostic.severity === 'error' ? '✗' : '!'} [${diagnostic.code}]${subject}: ${diagnostic.message}`;
+}
+function formatModulesResult(result) {
+    if (result.action === 'list') {
+        const lines = result.modules.map(module => (`${module.supportsHarmony ? '✓' : '-'} ${module.packageName}@${module.packageVersion} [${module.source}]`));
+        for (const packageName of result.missingIncludes) {
+            lines.push(`✗ missing required package ${packageName}`);
+        }
+        for (const duplicate of result.duplicates) {
+            lines.push(`! duplicate ${duplicate.packageName}: ${duplicate.revisions.map(item => item.version).join(', ')}`);
+        }
+        return lines.length === 0 ? 'No native module candidates were discovered.' : lines.join('\n');
+    }
+    if (result.action === 'verify') {
+        if (result.diagnostics.length === 0) {
+            return `✓ Verified ${result.modules.length} Harmony native module(s).`;
+        }
+        return result.diagnostics.map(formatDiagnostic).join('\n');
+    }
+    return result.modules.map((module) => {
+        const arkTsModules = module.harmony.modules.join(', ') || 'none';
+        const har = module.arkTs
+            ? `${module.arkTs.ohPackageName} <- ${module.arkTs.harPath}`
+            : 'none';
+        return [
+            `${module.packageName}@${module.packageVersion}`,
+            `  source: ${module.source}`,
+            `  packageRoot: ${module.packageRoot}`,
+            `  ArkTS modules: ${arkTsModules}`,
+            `  HAR: ${har}`,
+        ].join('\n');
+    }).join('\n');
+}

package/build/modules/options.d.ts

@@ -0,0 +1,10 @@
+export type ModulesAction = 'inspect' | 'list' | 'verify';
+declare function parseModulesArgs(argv: string[]): {
+    action: ModulesAction;
+    help: boolean;
+    project: string;
+    packageName: string;
+    nativeModulesDir: string;
+    variant: "debug" | "release" | undefined;
+};
+export { parseModulesArgs };

package/build/modules/options.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModulesArgs = parseModulesArgs;
+const args_1 = require("../args");
+const errors_1 = require("../errors");
+const ModuleOptions = {
+    ...args_1.CommonOptions,
+    'package': { short: 'p', type: 'string' },
+    'variant': { type: 'string' },
+    'native-modules-dir': { type: 'string' },
+};
+function parseModulesArgs(argv) {
+    const { positionals, values } = (0, args_1.parseArgs)(ModuleOptions, argv);
+    const action = positionals[0];
+    if (values.help && action === undefined) {
+        return {
+            action: 'list',
+            help: true,
+            project: undefined,
+            packageName: values.package,
+            nativeModulesDir: values['native-modules-dir'],
+            variant: values.variant,
+        };
+    }
+    if (!action || !['inspect', 'list', 'verify'].includes(action)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', 'modules requires one of: list, inspect, verify.', { operation: 'parse-arguments' });
+    }
+    if (positionals.length > 2) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unexpected modules positional argument: ${positionals[2]}`, { operation: 'parse-arguments' });
+    }
+    if (values.variant !== undefined && !['debug', 'release'].includes(values.variant)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `--variant must be debug or release, received: ${values.variant}`, { operation: 'parse-arguments' });
+    }
+    if (values.package !== undefined && action !== 'inspect') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--package is supported by modules inspect only.', { operation: 'parse-arguments' });
+    }
+    return {
+        action,
+        help: Boolean(values.help),
+        project: positionals[1],
+        packageName: values.package,
+        nativeModulesDir: values['native-modules-dir'],
+        variant: values.variant,
+    };
+}

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,6 @@
+export type { Change as CheckChange } from '@expo-harmony/prebuild-config/check';
+interface CheckOptions {
+    buildType?: 'debug' | 'release';
+}
+declare function checkAsync(project: any, options?: CheckOptions): Promise<import("@expo-harmony/prebuild-config/check").Result>;
+export { checkAsync };