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

package/README.md

@@ -0,0 +1,12 @@
+# @expo-harmony/expo-modules-autolinking
+
+[**GitHub 仓库**](https://github.com/renbaoshuo/expo-harmony/tree/master/packages/expo-modules-autolinking)
+
+为 HarmonyOS 上的 React Native 应用提供 Expo Modules 和 RNOH 原生模块自动链接能力，与官方同版本的 expo-modules-autolinking 配套使用。
+
+## Author
+
+**expo-harmony** © [Baoshuo](https://github.com/renbaoshuo), Released under the MIT License.<br>
+Authored and maintained by Baoshuo with help from [contributors](https://github.com/renbaoshuo/expo-harmony/contributors).
+
+> [Personal Website](https://baoshuo.ren) · [Blog](https://blog.baoshuo.ren) · GitHub [@renbaoshuo](https://github.com/renbaoshuo) · Twitter [@baoshuo](https://twitter.com/baoshuo)

package/bin/expo-harmony-autolinking.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import { runCliAsync } from '../src/commands/cli';
+
+runCliAsync(process.argv.slice(2)).then(
+  (exitCode) => {
+    process.exitCode = exitCode;
+  },
+  (error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 2;
+  }
+);

package/build/bin/expo-harmony-autolinking.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/bin/expo-harmony-autolinking.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("../src/commands/cli");
+(0, cli_1.runCliAsync)(process.argv.slice(2)).then((exitCode) => {
+    process.exitCode = exitCode;
+}, (error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 2;
+});

package/build/index.d.ts

@@ -0,0 +1,8 @@
+import { linkModulesAsync } from './src/autolinking/link';
+import { canonicalizeAutolinkingArtifacts } from './src/harmony/persistence/canonicalize';
+import { resolveModulesAsync } from './src/autolinking/resolve';
+import { searchModulesAsync } from './src/autolinking/search';
+import { verifyModulesAsync } from './src/autolinking/verify';
+import { normalizeHarmonyModuleMetadata } from './src/metadata/schema';
+export { canonicalizeAutolinkingArtifacts, linkModulesAsync, normalizeHarmonyModuleMetadata, resolveModulesAsync, searchModulesAsync, verifyModulesAsync, };
+export type { BuildType, CanonicalizeAutolinkingArtifactsOptions, CanonicalizedAutolinkingArtifacts, Diagnostic, DiagnosticSource, ExpoMetadata, HostMetadata, HarmonyModuleMetadata, LinkOptions, LinkResult, Logger, Manifest, ModuleDescriptor, ModuleArtifactDescriptor, ModuleSource, Platform, ResolveOptions, RnohMetadata, SearchOptions, SearchRecord, SearchResult, VerificationResult, VerifyOptions, } from './src/types';

package/build/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyModulesAsync = exports.searchModulesAsync = exports.resolveModulesAsync = exports.normalizeHarmonyModuleMetadata = exports.linkModulesAsync = exports.canonicalizeAutolinkingArtifacts = void 0;
+const link_1 = require("./src/autolinking/link");
+Object.defineProperty(exports, "linkModulesAsync", { enumerable: true, get: function () { return link_1.linkModulesAsync; } });
+const canonicalize_1 = require("./src/harmony/persistence/canonicalize");
+Object.defineProperty(exports, "canonicalizeAutolinkingArtifacts", { enumerable: true, get: function () { return canonicalize_1.canonicalizeAutolinkingArtifacts; } });
+const resolve_1 = require("./src/autolinking/resolve");
+Object.defineProperty(exports, "resolveModulesAsync", { enumerable: true, get: function () { return resolve_1.resolveModulesAsync; } });
+const search_1 = require("./src/autolinking/search");
+Object.defineProperty(exports, "searchModulesAsync", { enumerable: true, get: function () { return search_1.searchModulesAsync; } });
+const verify_1 = require("./src/autolinking/verify");
+Object.defineProperty(exports, "verifyModulesAsync", { enumerable: true, get: function () { return verify_1.verifyModulesAsync; } });
+const schema_1 = require("./src/metadata/schema");
+Object.defineProperty(exports, "normalizeHarmonyModuleMetadata", { enumerable: true, get: function () { return schema_1.normalizeHarmonyModuleMetadata; } });

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

@@ -0,0 +1,3 @@
+import type { LinkOptions, LinkResult } from '../types';
+declare function linkModulesAsync(rawOptions: LinkOptions): Promise<LinkResult>;
+export { linkModulesAsync };

package/build/src/autolinking/link.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkModulesAsync = linkModulesAsync;
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("../config/constants");
+const host_1 = require("../harmony/providers/host");
+const generate_1 = require("../harmony/manifest/generate");
+const errors_1 = require("../errors");
+const options_1 = require("../config/options");
+const link_1 = require("../harmony/rnoh/link");
+const stageProject_1 = require("../harmony/transaction/stageProject");
+const publish_1 = require("../harmony/transaction/publish");
+const previousState_1 = require("../harmony/transaction/previousState");
+const verify_1 = require("./verify");
+const values_1 = require("../utilities/values");
+const materialize_1 = require("../harmony/materialize");
+function buildPublishEntries(staging, hostProviderSource, manifest) {
+    return [
+        ...Object.entries(constants_1.RnohArtifacts).map(([name, relative]) => ({
+            source: staging.rnohArtifacts[name].path,
+            target: node_path_1.default.join(staging.harmonyProjectPath, relative),
+        })),
+        {
+            content: hostProviderSource,
+            target: node_path_1.default.join(staging.harmonyProjectPath, constants_1.ExpoArtifacts.hostProvider),
+        },
+        {
+            content: manifest,
+            target: node_path_1.default.join(staging.projectRoot, constants_1.ManifestArtifact),
+        },
+    ];
+}
+async function linkModulesAsync(rawOptions) {
+    const options = await (0, options_1.normalizeOptionsAsync)(rawOptions);
+    if (typeof rawOptions.harmonyProjectPath !== 'string' || !rawOptions.harmonyProjectPath) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'link requires harmonyProjectPath.', { stage: 'link' });
+    }
+    const verify = await (0, verify_1.verifyModulesAsync)((rawOptions.modules !== undefined
+        ? { modules: rawOptions.modules }
+        : { ...options, searchResult: rawOptions.searchResult }));
+    (0, verify_1.assertVerificationSucceeded)(verify, 'link');
+    const modules = verify.modules;
+    const pendingSource = modules.filter(module => module.artifact.kind === 'local-source');
+    if (pendingSource.length > 0) {
+        if (pendingSource.some(module => module.source !== 'nativeModulesDir')) {
+            throw new errors_1.HarmonyAutolinkingError('SOURCE_ARTIFACT_MATERIALIZATION_REQUIRED', 'Only nativeModulesDir modules may build a local Harmony HAR.', { stage: 'link', details: pendingSource.map(module => module.packageName).sort() });
+        }
+        await (0, materialize_1.materializeLocalSourcesAsync)(pendingSource, {
+            projectRoot: options.projectRoot,
+            timeoutMs: rawOptions.timeoutMs,
+            outputLimit: rawOptions.outputLimit,
+            env: rawOptions.env,
+        });
+    }
+    const hostProviderSource = (0, host_1.renderArkTsHostProviderSource)(modules);
+    let staging;
+    let failure;
+    let cleanupWarning;
+    const warnings = [];
+    try {
+        const previous = await (0, previousState_1.readPreviousAutolinkingStateAsync)(options.projectRoot);
+        if (previous.warning) {
+            warnings.push(previous.warning);
+            (0, values_1.emitLog)(rawOptions.logger, 'warn', previous.warning.message, previous.warning);
+        }
+        staging = await (0, stageProject_1.stageProjectAsync)({
+            projectRoot: options.projectRoot,
+            harmonyProjectPath: rawOptions.harmonyProjectPath,
+            nodeModulesPath: rawOptions.nodeModulesPath,
+            modules,
+            buildType: options.buildType,
+            previousManagedOhpmPackageNames: previous.managedOhpmPackageNames,
+            rnohCliPackageJsonPath: rawOptions.rnohCliPackageJsonPath,
+        });
+        staging.rnohArtifacts = await (0, link_1.linkRnohAsync)({
+            ...staging,
+            modules,
+            buildType: options.buildType,
+            exclude: staging.rnohRuntimePackages,
+            commandNodeModulesPath: staging.sourceNodeModulesPath,
+            reactNativeExecutable: rawOptions.reactNativeExecutable,
+            rnohCliPackageJsonPath: rawOptions.rnohCliPackageJsonPath,
+            timeoutMs: rawOptions.timeoutMs,
+            outputLimit: rawOptions.outputLimit,
+            env: rawOptions.env,
+        });
+        const harmonyRoot = node_path_1.default.relative(staging.projectRoot, staging.harmonyProjectPath)
+            .split(node_path_1.default.sep).join('/');
+        const managed = (0, constants_1.managedArtifactsForHarmonyRoot)(harmonyRoot);
+        const manifest = (0, generate_1.serializeManifest)(modules, {
+            buildType: options.buildType,
+            managedArtifacts: managed,
+        });
+        const published = await (0, publish_1.publishArtifactsAsync)({
+            allowedRoot: staging.projectRoot,
+            lockPath: node_path_1.default.join(staging.projectRoot, '.expo/harmony/autolinking.lock'),
+            files: buildPublishEntries(staging, hostProviderSource, manifest),
+            stale: previous.artifacts.filter(artifact => !managed.some((relative) => {
+                return artifact === node_path_1.default.join(staging.projectRoot, ...relative.split('/'));
+            })),
+        });
+        const result = {
+            platform: 'harmony',
+            modules,
+            buildType: options.buildType,
+            managedArtifacts: [...managed],
+            changedArtifacts: published.changed.map(target => node_path_1.default.relative(staging.projectRoot, target).split(node_path_1.default.sep).join('/')),
+            unchangedArtifacts: published.unchanged.map(target => node_path_1.default.relative(staging.projectRoot, target).split(node_path_1.default.sep).join('/')),
+            diagnostics: verify.diagnostics,
+            warnings,
+        };
+        (0, values_1.emitLog)(rawOptions.logger, 'info', 'Harmony autolinking completed.', {
+            moduleCount: result.modules.length,
+            changedArtifactCount: result.changedArtifacts.length,
+        });
+        return result;
+    }
+    catch (error) {
+        failure = error;
+        (0, values_1.emitLog)(rawOptions.logger, 'error', 'Harmony autolinking failed.', {
+            code: error.code || 'ERR_EXPO_HARMONY_UNKNOWN',
+            stage: error.stage || 'link',
+        });
+    }
+    finally {
+        if (staging) {
+            const cleanup = await (0, stageProject_1.cleanupStagingProjectAsync)(staging);
+            if (cleanup) {
+                const warning = { ...cleanup };
+                delete warning.cause;
+                warnings.push(warning);
+                (0, values_1.emitLog)(rawOptions.logger, 'warn', warning.message, warning);
+                if (failure)
+                    cleanupWarning = warning;
+            }
+        }
+    }
+    throw new errors_1.HarmonyAutolinkingError(typeof failure.code === 'string' ? failure.code : 'UNKNOWN', failure.message || 'Harmony autolinking failed.', {
+        cause: failure,
+        stage: failure.stage || 'link',
+        packageName: failure.packageName,
+        diagnostics: failure.diagnostics,
+        details: cleanupWarning
+            ? { ...(failure.details || {}), cleanupWarning }
+            : failure.details,
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { ModuleDescriptor, ResolveOptions } from '../types';
+declare function compareModuleDescriptors(left: any, right: any): 1 | -1 | 0;
+declare function resolveModulesAsync(options?: ResolveOptions): Promise<ModuleDescriptor[]>;
+export { compareModuleDescriptors, resolveModulesAsync, };

package/build/src/autolinking/resolve.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareModuleDescriptors = compareModuleDescriptors;
+exports.resolveModulesAsync = resolveModulesAsync;
+const search_1 = require("./search");
+const descriptor_1 = require("../metadata/descriptor");
+const values_1 = require("../utilities/values");
+function compareModuleDescriptors(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);
+}
+async function resolveModulesAsync(options = {}) {
+    const searchResult = options.searchResult || await (0, search_1.searchModulesAsync)(options);
+    const records = [...searchResult.modules].sort(compareModuleDescriptors);
+    const descriptors = [];
+    for (const record of records) {
+        descriptors.push(await (0, descriptor_1.createDescriptorFromSearchRecordAsync)(record, searchResult.options.buildType));
+    }
+    const result = descriptors.sort(compareModuleDescriptors);
+    (0, values_1.emitLog)(options.logger, 'debug', 'Harmony module resolution completed.', {
+        moduleCount: descriptors.length,
+    });
+    return result;
+}

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

@@ -0,0 +1,3 @@
+import type { SearchOptions, SearchResult } from '../types';
+declare function searchModulesAsync(rawOptions?: SearchOptions): Promise<SearchResult>;
+export { searchModulesAsync, };

package/build/src/autolinking/search.js

@@ -0,0 +1,357 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchModulesAsync = searchModulesAsync;
+const expoAutolinking = __importStar(require("expo-modules-autolinking/exports"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const constants_1 = require("../config/constants");
+const errors_1 = require("../errors");
+const options_1 = require("../config/options");
+const values_1 = require("../utilities/values");
+function loadUpstreamAutolinkingApi() {
+    const upstreamApi = expoAutolinking;
+    for (const name of ['makeCachedDependenciesLinker']) {
+        if (typeof upstreamApi[name] !== 'function') {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `expo-modules-autolinking public export ${name} is unavailable.`, { stage: 'search' });
+        }
+    }
+    return upstreamApi;
+}
+function supportsHarmony(config) {
+    return Array.isArray(config?.platforms) && config.platforms.includes(constants_1.Platform);
+}
+function hasHarmonyExpoMetadata(config) {
+    return supportsHarmony(config);
+}
+async function readExpoModuleConfigAsync(packageRoot) {
+    const target = node_path_1.default.join(packageRoot, 'expo-module.config.json');
+    return await (0, values_1.pathExistsAsync)(target)
+        ? (0, values_1.readJsonAsync)(target, 'INVALID_METADATA', 'search')
+        : null;
+}
+function nodeModulesDepth(originPath) {
+    return String(originPath).split(`${node_path_1.default.sep}node_modules${node_path_1.default.sep}`).length;
+}
+function isPreferredRevision(left, right) {
+    const leftDepth = Number.isInteger(left.depth) ? left.depth : Number.POSITIVE_INFINITY;
+    const rightDepth = Number.isInteger(right.depth) ? right.depth : Number.POSITIVE_INFINITY;
+    if (leftDepth !== rightDepth)
+        return leftDepth < rightDepth;
+    const leftNest = nodeModulesDepth(left.originPath);
+    const rightNest = nodeModulesDepth(right.originPath);
+    if (leftNest !== rightNest)
+        return leftNest < rightNest;
+    if (left.source !== right.source)
+        return left.source < right.source;
+    return (0, values_1.compareText)(left.originPath, right.originPath) < 0;
+}
+function mergeRevisions(resultSets) {
+    const merged = Object.create(null);
+    for (const results of resultSets) {
+        for (const packageName of Object.keys(results)) {
+            const incoming = results[packageName];
+            if (!incoming)
+                continue;
+            const current = merged[packageName];
+            if (!current) {
+                merged[packageName] = {
+                    ...incoming,
+                    duplicates: [...(incoming.duplicates || [])],
+                };
+                continue;
+            }
+            if (current.path === incoming.path) {
+                if (!current.version && incoming.version)
+                    current.version = incoming.version;
+                for (const candidate of incoming.duplicates || []) {
+                    if (candidate.path !== current.path
+                        && !current.duplicates.some(item => item.path === candidate.path)) {
+                        current.duplicates.push(candidate);
+                    }
+                }
+                continue;
+            }
+            let winner = current;
+            let duplicate = incoming;
+            if (isPreferredRevision(incoming, current)) {
+                winner = { ...incoming, duplicates: [...(incoming.duplicates || [])] };
+                duplicate = current;
+                merged[packageName] = winner;
+            }
+            const candidates = [
+                { ...duplicate, duplicates: undefined },
+                ...(duplicate.duplicates || []),
+            ];
+            for (const candidate of candidates) {
+                if (candidate.path !== winner.path
+                    && !(winner.duplicates || []).some(item => item.path === candidate.path)) {
+                    winner.duplicates.push(candidate);
+                }
+            }
+        }
+    }
+    return merged;
+}
+function classifySource(revision, packageRoot, options) {
+    if (revision.source === 2) {
+        return 'reactNativeProjectConfig';
+    }
+    if (options.nativeModulesDir
+        && (0, values_1.isPathInside)(options.nativeModulesDir, packageRoot)) {
+        return 'nativeModulesDir';
+    }
+    if (options.searchPaths.some(searchPath => (0, values_1.isPathInside)(searchPath, packageRoot))) {
+        return 'searchPath';
+    }
+    return 'dependency';
+}
+async function resolveDependencyRevisionsAsync(upstreamApi, options) {
+    const linker = upstreamApi.makeCachedDependenciesLinker({ projectRoot: options.projectRoot });
+    const resultSets = [];
+    if (options.includeReactNativeProjectConfig) {
+        resultSets.push(await linker.scanDependenciesFromRNProjectConfig());
+    }
+    if (options.nativeModulesDir && await (0, values_1.pathExistsAsync)(options.nativeModulesDir)) {
+        resultSets.push(await linker.scanDependenciesInSearchPath(options.nativeModulesDir));
+    }
+    for (const searchPath of options.searchPaths) {
+        if (await (0, values_1.pathExistsAsync)(searchPath)) {
+            resultSets.push(await linker.scanDependenciesInSearchPath(searchPath));
+        }
+    }
+    resultSets.push(await linker.scanDependenciesRecursively());
+    return mergeRevisions(resultSets);
+}
+async function loadOverridesAsync(deps) {
+    const overrides = Object.create(null);
+    const owners = Object.create(null);
+    const required = new Set();
+    for (const name of Object.keys(deps).sort(values_1.compareText)) {
+        const revision = deps[name];
+        if (!revision)
+            continue;
+        let packageRoot;
+        let packageJson;
+        try {
+            packageRoot = await node_fs_1.default.promises.realpath(revision.path);
+            packageJson = await (0, values_1.readJsonAsync)(node_path_1.default.join(packageRoot, 'package.json'), 'INVALID_METADATA', 'search');
+        }
+        catch (_cause) {
+            continue;
+        }
+        const packageName = typeof packageJson.name === 'string' && packageJson.name ? packageJson.name : name;
+        const harmony = (0, values_1.isObject)(packageJson.harmony) ? packageJson.harmony : {};
+        const declared = (0, options_1.normalizeModuleOverrides)(harmony.modules, {
+            code: 'INVALID_METADATA',
+            field: `${packageName} package.json#harmony.modules`,
+            stage: 'search',
+        });
+        const dependencies = (0, values_1.isObject)(packageJson.dependencies) ? packageJson.dependencies : {};
+        const optional = (0, values_1.isObject)(packageJson.optionalDependencies) ? packageJson.optionalDependencies : {};
+        const peers = (0, values_1.isObject)(packageJson.peerDependencies) ? packageJson.peerDependencies : {};
+        const peerMeta = (0, values_1.isObject)(packageJson.peerDependenciesMeta) ? packageJson.peerDependenciesMeta : {};
+        for (const [target, metadata] of Object.entries(declared)) {
+            if (![dependencies, optional, peers].some(group => Object.hasOwn(group, target))) {
+                throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${packageName} declares Harmony module ${target} but does not list it in a production dependency field.`, { packageName, stage: 'search' });
+            }
+            if (Object.hasOwn(dependencies, target)
+                || (Object.hasOwn(peers, target) && peerMeta[target]?.optional !== true)) {
+                required.add(target);
+            }
+            if (overrides[target] !== undefined && !(0, node_util_1.isDeepStrictEqual)(overrides[target], metadata)) {
+                throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${packageName} and ${owners[target]} declare conflicting Harmony metadata for ${target}.`, { packageName: target, stage: 'search' });
+            }
+            overrides[target] = metadata;
+            owners[target] = packageName;
+        }
+    }
+    return {
+        requiredTargets: required,
+        overrides: Object.freeze(overrides),
+        owners: Object.freeze(owners),
+    };
+}
+async function createSearchRecordAsync(revision, options) {
+    let packageRoot;
+    try {
+        packageRoot = await node_fs_1.default.promises.realpath(revision.path);
+    }
+    catch (_cause) {
+        return null;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let packageJson = {};
+    try {
+        packageJson = await (0, values_1.readJsonAsync)(node_path_1.default.join(packageRoot, 'package.json'), 'INVALID_METADATA', 'search');
+    }
+    catch (_cause) {
+        // Expo's search-path scanner tolerates roots without a readable
+        // package.json and falls back to the dependency revision name.
+    }
+    const packageName = typeof packageJson.name === 'string' && packageJson.name
+        ? packageJson.name
+        : revision.name;
+    if (options.exclude.includes(revision.name || packageName))
+        return null;
+    const expo = await readExpoModuleConfigAsync(packageRoot);
+    const harmony = hasHarmonyExpoMetadata(expo);
+    const metadata = (0, values_1.isObject)(packageJson.harmony) ? packageJson.harmony : null;
+    const sidecar = options.moduleOverrides[packageName];
+    let rnohMetadata = metadata?.autolinking === undefined ? null : metadata.autolinking;
+    if (sidecar !== undefined) {
+        const { version: _version, ...metadata } = sidecar;
+        rnohMetadata = metadata;
+    }
+    const included = options.include.includes(revision.name || packageName);
+    return {
+        packageName,
+        packageVersion: typeof packageJson.version === 'string' ? packageJson.version : String(revision.version || ''),
+        packageRoot,
+        source: classifySource(revision, packageRoot, options),
+        supportsHarmony: harmony,
+        expoModuleConfig: expo,
+        rnohMetadata,
+        nativeCandidate: harmony || rnohMetadata != null,
+        includedForVerification: included,
+        revision: {
+            depth: Number.isInteger(revision.depth) ? revision.depth : null,
+            originPath: typeof revision.originPath === 'string' ? revision.originPath : packageRoot,
+        },
+    };
+}
+function compareSearchRecords(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);
+}
+function findDuplicates(records) {
+    const byName = new Map();
+    for (const record of records) {
+        const revisions = byName.get(record.packageName) || [];
+        revisions.push({ version: record.packageVersion, path: record.packageRoot });
+        byName.set(record.packageName, revisions);
+    }
+    return [...byName.entries()]
+        .filter(([, revisions]) => new Set(revisions.map(revision => `${revision.version}\0${revision.path}`)).size > 1)
+        .map(([packageName, revisions]) => ({
+        packageName,
+        revisions: revisions.sort((left, right) => (0, values_1.compareText)(left.version, right.version)
+            || (0, values_1.compareText)(left.path, right.path)),
+    }))
+        .sort((left, right) => (0, values_1.compareText)(left.packageName, right.packageName));
+}
+async function searchModulesAsync(rawOptions = {}) {
+    const input = rawOptions;
+    const options = {
+        ...await (0, options_1.normalizeOptionsAsync)(rawOptions),
+        includeReactNativeProjectConfig: input.includeReactNativeProjectConfig === true,
+    };
+    const upstreamApi = loadUpstreamAutolinkingApi();
+    const deps = await resolveDependencyRevisionsAsync(upstreamApi, options);
+    const overrides = await loadOverridesAsync(deps);
+    const modules = Object.freeze({
+        ...overrides.overrides,
+        ...options.moduleOverrides,
+    });
+    const search = { ...options, moduleOverrides: modules };
+    const selected = new Map();
+    const unique = new Map();
+    for (const name of Object.keys(deps).sort(values_1.compareText)) {
+        const resolution = deps[name];
+        if (!resolution)
+            continue;
+        const revisions = [
+            resolution,
+            ...(resolution.duplicates || []).map(duplicate => ({
+                ...resolution,
+                ...duplicate,
+                duplicates: null,
+            })),
+        ];
+        const records = (await Promise.all(revisions.map(revision => createSearchRecordAsync(revision, search))))
+            .filter(Boolean);
+        const winner = records[0];
+        let chosen = winner?.nativeCandidate || winner?.includedForVerification ? winner : null;
+        if (!chosen && resolution.source === 1) {
+            chosen = records.slice(1).find(record => record.nativeCandidate || record.includedForVerification) || null;
+        }
+        if (!chosen)
+            continue;
+        if (chosen.nativeCandidate)
+            selected.set(chosen.packageName, chosen);
+        for (const record of records) {
+            const key = `${record.packageName}\0${record.packageVersion}\0${record.packageRoot}`;
+            if (!unique.has(key))
+                unique.set(key, record);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    for (const [packageName, sidecar] of Object.entries(modules)) {
+        const record = selected.get(packageName);
+        if (record && sidecar.version !== undefined && sidecar.version !== record.packageVersion) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `Harmony sidecar module ${packageName} targets ${sidecar.version}, but ${record.packageVersion} is installed.`, { packageName, stage: 'search' });
+        }
+    }
+    const all = [...unique.values()];
+    const found = new Set(all.map(record => record.packageName));
+    for (const [packageName, owner] of Object.entries(overrides.owners)) {
+        if (!found.has(packageName) && overrides.requiredTargets.has(packageName)) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${owner} declares Harmony module ${packageName}, but that dependency is not installed.`, { packageName, stage: 'search' });
+        }
+    }
+    const verified = all.filter(record => modules[record.packageName] === undefined || selected.get(record.packageName)?.packageRoot === record.packageRoot);
+    const records = [...selected.values()].map(({ includedForVerification: _includedForVerification, nativeCandidate: _nativeCandidate, ...record }) => record).sort(compareSearchRecords);
+    const result = {
+        platform: constants_1.Platform,
+        modules: records,
+        duplicates: findDuplicates(verified),
+        missingIncludes: options.include.filter(name => !found.has(name)).sort(values_1.compareText),
+        options: {
+            projectRoot: options.projectRoot,
+            searchPaths: options.searchPaths,
+            nativeModulesDir: options.nativeModulesDir,
+            exclude: options.exclude,
+            include: options.include,
+            buildType: options.buildType,
+        },
+    };
+    (0, values_1.emitLog)(rawOptions.logger, 'debug', 'Harmony module search completed.', { moduleCount: records.length, duplicateCount: result.duplicates.length });
+    return result;
+}

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

@@ -0,0 +1,4 @@
+import type { VerificationResult, VerifyOptions } from '../types';
+declare function verifyModulesAsync(options?: VerifyOptions): Promise<VerificationResult>;
+declare function assertVerificationSucceeded(result: any, stage?: string): void;
+export { assertVerificationSucceeded, verifyModulesAsync, };