@expo-harmony/expo-modules-autolinking 55.0.25-harmony.1

package/build/src/autolinking/verify.js

@@ -0,0 +1,366 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertVerificationSucceeded = assertVerificationSucceeded;
+exports.verifyModulesAsync = verifyModulesAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../errors");
+const host_1 = require("../metadata/host");
+const descriptor_1 = require("../metadata/descriptor");
+const search_1 = require("./search");
+const resolve_1 = require("./resolve");
+const packageMetadata_1 = require("../harmony/rnoh/packageMetadata");
+const host_2 = require("../harmony/providers/host");
+const values_1 = require("../utilities/values");
+function diagnosticFromError(error, fallback) {
+    const normalized = error instanceof errors_1.HarmonyAutolinkingError
+        ? error
+        : new errors_1.HarmonyAutolinkingError('INVALID_METADATA', error.message || String(error), { cause: error, packageName: fallback, stage: 'verify' });
+    return {
+        severity: 'error',
+        code: normalized.code,
+        message: normalized.message,
+        ...(normalized.packageName || fallback ? { packageName: normalized.packageName || fallback } : {}),
+        stage: normalized.stage,
+    };
+}
+function compareDiagnostics(left, right) {
+    const order = { error: 0, warning: 1 };
+    return (order[left.severity] - order[right.severity])
+        || (0, values_1.compareText)(left.code, right.code)
+        || (0, values_1.compareText)(left.packageName || '', right.packageName || '')
+        || (0, values_1.compareText)(left.message, right.message)
+        || (0, values_1.compareText)(JSON.stringify(left.sources || []), JSON.stringify(right.sources || []));
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function diagnosticSource(descriptor, extra = {}) {
+    return {
+        packageName: descriptor.packageName,
+        packageVersion: descriptor.packageVersion,
+        packageRoot: descriptor.packageRoot,
+        ...extra,
+    };
+}
+function conflictDiagnostic(code, label, value, entries, packageName, severity = 'error') {
+    return {
+        severity,
+        code: `ERR_EXPO_HARMONY_${code}`,
+        message: `${label} "${value}" is declared more than once.`,
+        packageName,
+        stage: 'verify',
+        sources: entries.map(entry => entry.source).sort((left, right) => {
+            return (0, values_1.compareText)(left.packageName, right.packageName)
+                || (0, values_1.compareText)(left.packageRoot, right.packageRoot)
+                || (0, values_1.compareText)(left.field || '', right.field || '');
+        }),
+    };
+}
+function collectDescriptorConflicts(descriptors) {
+    const diagnostics = [];
+    const registrations = new Map();
+    const oh = new Map();
+    const rnohCmakeTargets = new Map();
+    const rnohEtsSymbols = new Map();
+    const rnohCppSymbols = new Map();
+    function push(map, key, source, value = key) {
+        const entries = map.get(key) || [];
+        entries.push({ value, source });
+        map.set(key, entries);
+    }
+    for (const descriptor of descriptors) {
+        if (descriptor.arkTs) {
+            const arkTs = descriptor.arkTs;
+            push(oh, arkTs.ohPackageName, diagnosticSource(descriptor, {
+                field: `HAR:${arkTs.harPath}`,
+            }), `${descriptor.packageRoot}\0${arkTs.harPath}`);
+            for (const moduleClass of descriptor.harmony.modules) {
+                const registrationId = (0, host_2.moduleRegistrationId)(arkTs.ohPackageName, moduleClass);
+                push(registrations, registrationId, diagnosticSource(descriptor, {
+                    field: `module:${moduleClass}`,
+                }));
+            }
+        }
+        if (descriptor.rnoh.harPaths.length > 0) {
+            const rnohMetadata = (0, packageMetadata_1.resolveRnohMetadata)(descriptor);
+            const packageSource = `${descriptor.packageRoot}\0${rnohMetadata.harMappings
+                .map(mapping => mapping.harPath)
+                .join('\0')}`;
+            for (const mapping of rnohMetadata.harMappings) {
+                push(oh, mapping.ohPackageName, diagnosticSource(descriptor, {
+                    field: `HAR:${mapping.harPath}`,
+                }), `${descriptor.packageRoot}\0${mapping.harPath}`);
+            }
+            push(rnohEtsSymbols, rnohMetadata.etsPackageClassName, diagnosticSource(descriptor, {
+                field: 'etsPackageClassName',
+            }), packageSource);
+            push(rnohCppSymbols, rnohMetadata.cppPackageClassName, diagnosticSource(descriptor, {
+                field: 'cppPackageClassName',
+            }), packageSource);
+            push(rnohCmakeTargets, rnohMetadata.cmakeLibraryTargetName, diagnosticSource(descriptor, {
+                field: 'cmakeLibraryTargetName',
+            }), packageSource);
+        }
+    }
+    for (const [value, entries] of registrations) {
+        if (entries.length > 1) {
+            diagnostics.push(conflictDiagnostic('DUPLICATE_MODULE', 'ArkTS module registration', value, entries));
+        }
+    }
+    for (const [value, entries] of rnohCmakeTargets) {
+        if (new Set(entries.map(entry => entry.value)).size > 1) {
+            diagnostics.push(conflictDiagnostic('DUPLICATE_MODULE', 'CMake target', value, entries));
+        }
+    }
+    for (const [value, entries] of rnohEtsSymbols) {
+        if (new Set(entries.map(entry => entry.value)).size > 1) {
+            diagnostics.push(conflictDiagnostic('DUPLICATE_MODULE', 'ETS Package class', value, entries));
+        }
+    }
+    for (const [value, entries] of rnohCppSymbols) {
+        if (new Set(entries.map(entry => entry.value)).size > 1) {
+            diagnostics.push(conflictDiagnostic('DUPLICATE_MODULE', 'C++ Package class', value, entries));
+        }
+    }
+    for (const [value, entries] of oh) {
+        if (new Set(entries.map(entry => entry.value)).size > 1) {
+            diagnostics.push(conflictDiagnostic('DUPLICATE_MODULE', 'OH package', value, entries));
+        }
+    }
+    return diagnostics;
+}
+function normalizeDescriptorHarPaths(descriptor) {
+    if (!Array.isArray(descriptor.rnoh.harPaths)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'descriptor.rnoh.harPaths must be an array.', {
+            packageName: descriptor.packageName,
+            stage: 'verify',
+        });
+    }
+    const harPaths = descriptor.rnoh.harPaths.map((harPath, index) => {
+        if (typeof harPath !== 'string' || !harPath.trim() || harPath.includes('\0')
+            || node_path_1.default.win32.isAbsolute(harPath)) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `descriptor.rnoh.harPaths[${index}] must be a non-empty package-relative HAR path.`, { packageName: descriptor.packageName, stage: 'verify' });
+        }
+        const normalized = node_path_1.default.posix.normalize(harPath.replace(/\\/g, '/'));
+        if (node_path_1.default.posix.isAbsolute(normalized) || normalized === '..' || normalized.startsWith('../')
+            || node_path_1.default.posix.extname(normalized) !== '.har') {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `descriptor.rnoh.harPaths[${index}] must be a package-relative .har file.`, { packageName: descriptor.packageName, stage: 'verify' });
+        }
+        return normalized;
+    });
+    return (0, values_1.sortedUniqueStrings)(harPaths);
+}
+function harRoot(harPaths) {
+    const directories = harPaths.map(harPath => node_path_1.default.posix.dirname(harPath).split('/'));
+    const common = [];
+    for (let index = 0; index < directories[0].length; index += 1) {
+        const segment = directories[0][index];
+        if (directories.every(parts => parts[index] === segment))
+            common.push(segment);
+        else
+            break;
+    }
+    return common.length === 0 ? '.' : common.join('/');
+}
+function searchRecordFromDescriptor(descriptor, declared) {
+    if (!(0, values_1.isObject)(descriptor)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'Harmony module descriptor must be an object.', {
+            stage: 'verify',
+        });
+    }
+    if (!(0, values_1.isObject)(descriptor.expo) || !(0, values_1.isObject)(descriptor.harmony)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'descriptor.expo and descriptor.harmony must be objects.', {
+            packageName: descriptor.packageName,
+            stage: 'verify',
+        });
+    }
+    if (!(0, values_1.isObject)(descriptor.rnoh)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'descriptor.rnoh must be an object.', {
+            packageName: descriptor.packageName,
+            stage: 'verify',
+        });
+    }
+    const host = host_1.HostMetadataFields.some(field => descriptor.expo[field]?.length > 0);
+    const modules = Array.isArray(descriptor.harmony.modules)
+        ? [...descriptor.harmony.modules]
+        : [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const rnoh = {};
+    if (descriptor.rnoh.ohPackageName !== undefined) {
+        rnoh.ohPackageName = Array.isArray(descriptor.rnoh.ohPackageName)
+            ? descriptor.rnoh.ohPackageName.map(mapping => ({ ...mapping }))
+            : descriptor.rnoh.ohPackageName;
+    }
+    if (descriptor.rnoh.mainHarPath !== undefined)
+        rnoh.mainHarPath = descriptor.rnoh.mainHarPath;
+    else if (declared.length > 0)
+        rnoh.mainHarPath = harRoot(declared);
+    if (descriptor.rnoh.etsPackageImport !== undefined) {
+        rnoh.etsPackageImport = descriptor.rnoh.etsPackageImport;
+    }
+    if (descriptor.rnoh.etsPackageClassName !== undefined) {
+        rnoh.etsPackageClassName = descriptor.rnoh.etsPackageClassName;
+    }
+    if (descriptor.rnoh.cppPackageClassName !== undefined) {
+        rnoh.cppPackageClassName = descriptor.rnoh.cppPackageClassName;
+    }
+    if (descriptor.rnoh.cmakeLibraryTargetName !== undefined) {
+        rnoh.cmakeLibraryTargetName = descriptor.rnoh.cmakeLibraryTargetName;
+    }
+    return {
+        packageName: descriptor.packageName,
+        packageVersion: descriptor.packageVersion,
+        packageRoot: descriptor.packageRoot,
+        source: descriptor.source,
+        supportsHarmony: modules.length > 0 || host,
+        expoModuleConfig: modules.length > 0 || host
+            ? {
+                platforms: ['harmony'],
+                harmony: {
+                    modules,
+                    ...Object.fromEntries(host_1.HostMetadataFields.map(field => [
+                        field,
+                        [...(descriptor.expo[field] || [])],
+                    ])),
+                },
+            }
+            : null,
+        rnohMetadata: Object.keys(rnoh).length > 0 ? rnoh : null,
+        revision: {
+            originPath: descriptor.packageLinkPath || descriptor.packageRoot,
+        },
+    };
+}
+async function validateDescriptorAsync(descriptor, buildType) {
+    if (!(0, values_1.isObject)(descriptor) || !(0, values_1.isObject)(descriptor.rnoh)) {
+        return (0, descriptor_1.createDescriptorFromSearchRecordAsync)(searchRecordFromDescriptor(descriptor, []), buildType);
+    }
+    const declared = normalizeDescriptorHarPaths(descriptor);
+    const normalized = await (0, descriptor_1.createDescriptorFromSearchRecordAsync)(searchRecordFromDescriptor(descriptor, declared), buildType);
+    if (normalized.rnoh.harPaths.length !== declared.length
+        || normalized.rnoh.harPaths.some((harPath, index) => harPath !== declared[index])) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'descriptor.rnoh.harPaths must exactly list the HAR files selected by descriptor.rnoh.mainHarPath.', {
+            packageName: descriptor.packageName,
+            stage: 'verify',
+            details: { declared, discovered: normalized.rnoh.harPaths },
+        });
+    }
+    const packageRoot = await node_fs_1.default.promises.realpath(descriptor.packageRoot);
+    if (packageRoot !== descriptor.packageRoot) {
+        normalized.packageRoot = packageRoot;
+    }
+    return normalized;
+}
+async function verifyModulesAsync(options = {}) {
+    let searchResult = options.searchResult;
+    const inputs = options.modules;
+    if (inputs !== undefined && !Array.isArray(inputs)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'modules must be an array when provided.', { stage: 'verify' });
+    }
+    if (!searchResult && inputs === undefined) {
+        const runtime = [
+            '@react-native-oh/react-native-harmony',
+            'react-native',
+            'react-native-tvos',
+        ].filter((packageName) => {
+            try {
+                (0, values_1.resolvePackageFromProject)(options.projectRoot || process.cwd(), `${packageName}/package.json`);
+                return true;
+            }
+            catch (_cause) {
+                return false;
+            }
+        });
+        searchResult = await (0, search_1.searchModulesAsync)({
+            ...options,
+            include: [...(options.include || []), ...runtime],
+            includeReactNativeProjectConfig: true,
+        });
+    }
+    const descriptors = [];
+    const diagnostics = [];
+    const buildType = searchResult?.options.buildType || options.buildType || 'debug';
+    if (inputs !== undefined) {
+        for (const input of inputs) {
+            try {
+                descriptors.push(await validateDescriptorAsync(input, buildType));
+            }
+            catch (error) {
+                diagnostics.push(diagnosticFromError(error, input?.packageName));
+            }
+        }
+    }
+    else {
+        const records = [...searchResult.modules].sort((left, right) => {
+            return (0, values_1.compareText)(left.packageName, right.packageName)
+                || (0, values_1.compareText)(left.packageVersion, right.packageVersion)
+                || (0, values_1.compareText)(left.packageRoot, right.packageRoot);
+        });
+        for (const record of records) {
+            try {
+                descriptors.push(await (0, descriptor_1.createDescriptorFromSearchRecordAsync)(record, buildType));
+            }
+            catch (error) {
+                diagnostics.push(diagnosticFromError(error, record.packageName));
+            }
+        }
+        for (const packageName of (0, values_1.sortedUniqueStrings)(searchResult.missingIncludes || [])) {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'ERR_EXPO_HARMONY_INCLUDED_MODULE_NOT_FOUND',
+                message: `Included package "${packageName}" was not found.`,
+                packageName,
+                stage: 'verify',
+            });
+        }
+    }
+    descriptors.sort(resolve_1.compareModuleDescriptors);
+    diagnostics.push(...collectDescriptorConflicts(descriptors));
+    if (searchResult) {
+        const seen = new Map();
+        for (const descriptor of descriptors) {
+            const set = seen.get(descriptor.packageName) || new Set();
+            set.add(`${descriptor.packageVersion}\0${descriptor.packageRoot}`);
+            seen.set(descriptor.packageName, set);
+        }
+        for (const duplicate of searchResult.duplicates || []) {
+            const list = [...new Map(duplicate.revisions.map(revision => [
+                    `${revision.version}\0${revision.path}`, revision,
+                ])).values()];
+            if (list.length < 2 || (seen.get(duplicate.packageName)?.size || 0) >= list.length) {
+                continue;
+            }
+            diagnostics.push(conflictDiagnostic('DUPLICATE_MODULE', 'npm package', duplicate.packageName, list.map(revision => ({
+                source: {
+                    packageName: duplicate.packageName,
+                    packageVersion: revision.version,
+                    packageRoot: revision.path,
+                },
+            })), duplicate.packageName, 'warning'));
+        }
+    }
+    diagnostics.sort(compareDiagnostics);
+    const result = {
+        valid: diagnostics.every(diagnostic => diagnostic.severity !== 'error'),
+        diagnostics,
+        modules: descriptors,
+    };
+    (0, values_1.emitLog)(options.logger, result.valid ? 'debug' : 'warn', 'Harmony module verification completed.', {
+        valid: result.valid,
+        diagnosticCount: diagnostics.length,
+        moduleCount: descriptors.length,
+    });
+    return result;
+}
+function assertVerificationSucceeded(result, stage = 'verify') {
+    if (result.valid)
+        return;
+    const first = result.diagnostics.find(diagnostic => diagnostic.severity === 'error');
+    throw new errors_1.HarmonyAutolinkingError(first?.code || 'INVALID_METADATA', 'Harmony module verification failed.', {
+        diagnostics: result.diagnostics,
+        packageName: first?.packageName,
+        stage,
+    });
+}

package/build/src/commands/autolinkingOptions.d.ts

@@ -0,0 +1,12 @@
+declare function parsePositiveInt(value: any): number;
+declare function addCommonOptions(command: any): any;
+declare function toApiOptions(options: any, searchPaths?: any): {
+    buildType?: any;
+    include?: any;
+    exclude?: any;
+    nativeModulesDir?: any;
+    searchPaths?: any;
+    platform: any;
+    projectRoot: any;
+};
+export { addCommonOptions, parsePositiveInt, toApiOptions };

package/build/src/commands/autolinkingOptions.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommonOptions = addCommonOptions;
+exports.parsePositiveInt = parsePositiveInt;
+exports.toApiOptions = toApiOptions;
+const commander_1 = require("commander");
+const constants_1 = require("../config/constants");
+function parsePositiveInt(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new commander_1.InvalidOptionArgumentError('Expected a positive integer.');
+    }
+    return parsed;
+}
+function addCommonOptions(command) {
+    command
+        .option('-e, --exclude <exclude...>', 'package names to exclude when looking up for modules', (value, previous = []) => previous.concat(value))
+        .option('-p, --platform [platform]', 'the platform that the resulting modules must support. Available options: "harmony"', constants_1.Platform)
+        .option('--project-root <projectRoot>', 'the path to the root of the project. Defaults to current working directory', process.cwd())
+        .option('--native-modules-dir <path>', 'replace configured local native modules directory')
+        .option('--include <include...>', 'package names to verify for duplicate revisions', (value, previous = []) => previous.concat(value))
+        .option('--build-type <type>', 'debug or release');
+    return command;
+}
+function toApiOptions(options, searchPaths = undefined) {
+    return {
+        platform: options.platform,
+        projectRoot: options.projectRoot,
+        ...(searchPaths !== undefined && searchPaths !== null ? { searchPaths } : {}),
+        ...(options.nativeModulesDir !== undefined ? { nativeModulesDir: options.nativeModulesDir } : {}),
+        ...(options.exclude !== undefined ? { exclude: options.exclude } : {}),
+        ...(options.include !== undefined ? { include: options.include } : {}),
+        ...(options.buildType !== undefined ? { buildType: options.buildType } : {}),
+    };
+}

package/build/src/commands/cli.d.ts

@@ -0,0 +1,2 @@
+declare function runCliAsync(argv: string[], io?: Record<string, any>): Promise<number>;
+export { runCliAsync };

package/build/src/commands/cli.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCliAsync = runCliAsync;
+const commander_1 = require("commander");
+const errors_1 = require("../errors");
+const constants_1 = require("../config/constants");
+const values_1 = require("../utilities/values");
+const link_1 = require("./link");
+const resolve_1 = require("./resolve");
+const search_1 = require("./search");
+const verify_1 = require("./verify");
+function createProgram(io, state) {
+    const program = new commander_1.Command();
+    program
+        .name('expo-harmony-autolinking')
+        .description('Expo Modules and RNOH autolinking for HarmonyOS')
+        .version(constants_1.ToolVersion)
+        .exitOverride()
+        .configureOutput({
+        writeOut: value => io.stdout(value),
+        writeErr: () => { },
+    });
+    (0, search_1.registerSearchCommand)(program, io);
+    (0, resolve_1.registerResolveCommand)(program, io);
+    (0, verify_1.registerVerifyCommand)(program, io, state);
+    (0, link_1.registerLinkCommand)(program, io);
+    return program;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function runCliAsync(argv, io = {}) {
+    const streams = {
+        stdout: io.stdout || (value => process.stdout.write(value)),
+        stderr: io.stderr || (value => process.stderr.write(value)),
+    };
+    const state = { exitCode: 0 };
+    const program = createProgram(streams, state);
+    try {
+        await program.parseAsync(argv, { from: 'user' });
+        return state.exitCode;
+    }
+    catch (error) {
+        if (error instanceof commander_1.CommanderError && error.exitCode === 0)
+            return 0;
+        const normalized = error instanceof errors_1.HarmonyAutolinkingError
+            ? error
+            : new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', error.message || String(error), { cause: error, stage: 'cli' });
+        streams.stderr((0, values_1.stringifyJson)(normalized.toJSON()));
+        return error instanceof commander_1.CommanderError ? Math.max(1, error.exitCode || 2) : 2;
+    }
+}

package/build/src/commands/link.d.ts

@@ -0,0 +1,2 @@
+declare function registerLinkCommand(program: any, io: any): void;
+export { registerLinkCommand };

package/build/src/commands/link.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLinkCommand = registerLinkCommand;
+const link_1 = require("../autolinking/link");
+const autolinkingOptions_1 = require("./autolinkingOptions");
+const output_1 = require("./output");
+function registerLinkCommand(program, io) {
+    (0, autolinkingOptions_1.addCommonOptions)(program.command('link [searchPaths...]').description('transactionally link Expo and RNOH modules'))
+        .requiredOption('--harmony-project-path <path>', 'Harmony project root')
+        .option('--node-modules-path <path>', 'node_modules directory')
+        .option('--react-native-executable <path>', 'explicit project-local react-native executable')
+        .option('--rnoh-cli-package-json <path>', 'explicit RNOH CLI package.json')
+        .option('--timeout-ms <milliseconds>', 'RNOH command timeout', autolinkingOptions_1.parsePositiveInt)
+        .option('--output-limit <bytes>', 'per-stream output capture limit', autolinkingOptions_1.parsePositiveInt)
+        .option('-j, --json', 'output results in the plain JSON format', false)
+        .action(async (searchPaths, options) => {
+        (0, output_1.writeResult)(io, await (0, link_1.linkModulesAsync)({
+            ...(0, autolinkingOptions_1.toApiOptions)(options, searchPaths),
+            harmonyProjectPath: options.harmonyProjectPath,
+            nodeModulesPath: options.nodeModulesPath,
+            reactNativeExecutable: options.reactNativeExecutable,
+            rnohCliPackageJsonPath: options.rnohCliPackageJson,
+            timeoutMs: options.timeoutMs,
+            outputLimit: options.outputLimit,
+        }), options);
+    });
+}

package/build/src/commands/output.d.ts

@@ -0,0 +1,3 @@
+declare function writeResult(io: any, value: any, options?: Record<string, any>): void;
+declare function writeVerifyResult(io: any, result: any, options?: Record<string, any>): void;
+export { writeResult, writeVerifyResult };

package/build/src/commands/output.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeResult = writeResult;
+exports.writeVerifyResult = writeVerifyResult;
+const node_util_1 = require("node:util");
+const values_1 = require("../utilities/values");
+function formatResult(value) {
+    return (0, node_util_1.inspect)(value, { depth: null, colors: false });
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function writeResult(io, value, options = {}) {
+    io.stdout(options.json ? (0, values_1.stringifyJson)(value) : `${formatResult(value)}\n`);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function writeVerifyResult(io, result, options = {}) {
+    if (options.json) {
+        writeResult(io, result, options);
+        return;
+    }
+    if (result.diagnostics.length === 0) {
+        io.stdout('✅ Everything is fine!\n');
+    }
+    else {
+        for (const diagnostic of result.diagnostics) {
+            const icon = diagnostic.severity === 'error' ? '❌' : '⚠️';
+            const suffix = diagnostic.packageName ? ` (${diagnostic.packageName})` : '';
+            io.stdout(`${icon} [${diagnostic.code}] ${diagnostic.message}${suffix}\n`);
+        }
+    }
+    if (options.verbose) {
+        io.stdout(`${formatResult({ modules: result.modules })}\n`);
+    }
+}

package/build/src/commands/resolve.d.ts

@@ -0,0 +1,2 @@
+declare function registerResolveCommand(program: any, io: any): void;
+export { registerResolveCommand };

package/build/src/commands/resolve.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerResolveCommand = registerResolveCommand;
+const resolve_1 = require("../autolinking/resolve");
+const autolinkingOptions_1 = require("./autolinkingOptions");
+const output_1 = require("./output");
+function registerResolveCommand(program, io) {
+    (0, autolinkingOptions_1.addCommonOptions)(program.command('resolve [searchPaths...]').description('resolve Harmony module metadata'))
+        .option('-j, --json', 'output results in the plain JSON format', false)
+        .action(async (searchPaths, options) => {
+        (0, output_1.writeResult)(io, await (0, resolve_1.resolveModulesAsync)((0, autolinkingOptions_1.toApiOptions)(options, searchPaths)), options);
+    });
+}

package/build/src/commands/search.d.ts

@@ -0,0 +1,2 @@
+declare function registerSearchCommand(program: any, io: any): void;
+export { registerSearchCommand };

package/build/src/commands/search.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSearchCommand = registerSearchCommand;
+const search_1 = require("../autolinking/search");
+const autolinkingOptions_1 = require("./autolinkingOptions");
+const output_1 = require("./output");
+function registerSearchCommand(program, io) {
+    (0, autolinkingOptions_1.addCommonOptions)(program.command('search [searchPaths...]').description('discover Harmony native module candidates'))
+        .option('-j, --json', 'output results in the plain JSON format', false)
+        .action(async (searchPaths, options) => {
+        (0, output_1.writeResult)(io, await (0, search_1.searchModulesAsync)((0, autolinkingOptions_1.toApiOptions)(options, searchPaths)), options);
+    });
+}

package/build/src/commands/verify.d.ts

@@ -0,0 +1,2 @@
+declare function registerVerifyCommand(program: any, io: any, state: any): void;
+export { registerVerifyCommand };

package/build/src/commands/verify.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVerifyCommand = registerVerifyCommand;
+const verify_1 = require("../autolinking/verify");
+const autolinkingOptions_1 = require("./autolinkingOptions");
+const output_1 = require("./output");
+function registerVerifyCommand(program, io, state) {
+    (0, autolinkingOptions_1.addCommonOptions)(program.command('verify').description('verify Harmony module metadata and conflicts'))
+        .option('-v, --verbose', 'output all verification details', false)
+        .option('-j, --json', 'output results in the plain JSON format', false)
+        .action(async (options) => {
+        const result = await (0, verify_1.verifyModulesAsync)((0, autolinkingOptions_1.toApiOptions)(options));
+        (0, output_1.writeVerifyResult)(io, result, options);
+        if (!result.valid)
+            state.exitCode = 1;
+    });
+}

package/build/src/config/constants.d.ts

@@ -0,0 +1,17 @@
+declare const Platform = "harmony";
+declare const RnohCliPackage = "@react-native-oh/react-native-harmony-cli";
+declare const ToolVersion: any;
+declare const ManifestSchemaVersion = 3;
+declare const RnohArtifacts: Readonly<{
+    etsFactory: "entry/src/main/ets/RNOHPackagesFactory.ets";
+    cppFactory: "entry/src/main/cpp/RNOHPackagesFactory.h";
+    cmake: "entry/src/main/cpp/autolinking.cmake";
+    ohPackage: "oh-package.json5";
+}>;
+declare const ExpoArtifacts: Readonly<{
+    hostProvider: "entry/src/main/ets/generated/ExpoHarmonyHostProvider.ets";
+}>;
+declare const ManifestArtifact = ".expo/harmony/autolinking.json";
+declare function managedArtifactsForHarmonyRoot(harmonyRoot: any): readonly string[];
+declare const ManagedArtifacts: readonly string[];
+export { ExpoArtifacts, ManagedArtifacts, ManifestArtifact, ManifestSchemaVersion, managedArtifactsForHarmonyRoot, Platform, RnohArtifacts, RnohCliPackage, ToolVersion, };

package/build/src/config/constants.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolVersion = exports.RnohCliPackage = exports.RnohArtifacts = exports.Platform = exports.ManifestSchemaVersion = exports.ManifestArtifact = exports.ManagedArtifacts = exports.ExpoArtifacts = void 0;
+exports.managedArtifactsForHarmonyRoot = managedArtifactsForHarmonyRoot;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const Platform = 'harmony';
+exports.Platform = Platform;
+const RnohCliPackage = '@react-native-oh/react-native-harmony-cli';
+exports.RnohCliPackage = RnohCliPackage;
+const ToolVersion = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.resolve(__dirname, '../../../package.json'), 'utf8')).version;
+exports.ToolVersion = ToolVersion;
+const ManifestSchemaVersion = 3;
+exports.ManifestSchemaVersion = ManifestSchemaVersion;
+const RnohArtifacts = Object.freeze({
+    etsFactory: 'entry/src/main/ets/RNOHPackagesFactory.ets',
+    cppFactory: 'entry/src/main/cpp/RNOHPackagesFactory.h',
+    cmake: 'entry/src/main/cpp/autolinking.cmake',
+    ohPackage: 'oh-package.json5',
+});
+exports.RnohArtifacts = RnohArtifacts;
+const ExpoArtifacts = Object.freeze({
+    hostProvider: 'entry/src/main/ets/generated/ExpoHarmonyHostProvider.ets',
+});
+exports.ExpoArtifacts = ExpoArtifacts;
+const ManifestArtifact = '.expo/harmony/autolinking.json';
+exports.ManifestArtifact = ManifestArtifact;
+function managedArtifactsForHarmonyRoot(harmonyRoot) {
+    const prefix = String(harmonyRoot).replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/$/, '');
+    const withinHarmony = [
+        ...Object.values(RnohArtifacts),
+        ...Object.values(ExpoArtifacts),
+    ].map(relative => prefix ? `${prefix}/${relative}` : relative);
+    return Object.freeze([...withinHarmony, ManifestArtifact]);
+}
+const ManagedArtifacts = managedArtifactsForHarmonyRoot('harmony');
+exports.ManagedArtifacts = ManagedArtifacts;