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

package/build/src/harmony/materialize.js

@@ -0,0 +1,278 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materializeLocalSourcesAsync = materializeLocalSourcesAsync;
+exports.materializeModuleArtifactAsync = materializeModuleArtifactAsync;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const errors_1 = require("../errors");
+const values_1 = require("../utilities/values");
+const publish_1 = require("./transaction/publish");
+const DefaultBuildTimeoutMs = 10 * 60_000;
+const DefaultOutputLimit = 64 * 1024;
+const HarmonyProjectPath = 'harmony';
+const HarmonyBuildOutputPath = 'library/build/default/outputs/default/library.har';
+function materializationError(code, message, options, details) {
+    throw new errors_1.HarmonyAutolinkingError(code, message, {
+        packageName: options.packageName,
+        stage: 'artifact-materialize',
+        details,
+    });
+}
+function createFixedHvigorBuildDescriptor(projectPath, buildType) {
+    return {
+        executable: 'hvigorw',
+        cwd: projectPath,
+        args: [
+            '--mode', 'module',
+            '-p', 'module=library@default',
+            '-p', 'product=default',
+            '-p', `buildMode=${buildType}`,
+            '--no-daemon',
+            'assembleHar',
+        ],
+    };
+}
+async function isNonEmptyRegularHarAsync(harPath, allowedRoot, packageName) {
+    const root = path.resolve(allowedRoot);
+    const target = path.resolve(harPath);
+    if (!(0, values_1.isPathInside)(root, target)) {
+        throw new errors_1.HarmonyAutolinkingError('UNSAFE_SOURCE_ARTIFACT', 'Harmony HAR path must stay inside its expected package or project root.', { packageName, stage: 'artifact-materialize' });
+    }
+    let stat;
+    try {
+        stat = await fs.promises.lstat(target);
+    }
+    catch (cause) {
+        if (cause.code === 'ENOENT')
+            return false;
+        throw new errors_1.HarmonyAutolinkingError('UNSAFE_SOURCE_ARTIFACT', 'Harmony HAR could not be checked safely.', { cause, packageName, stage: 'artifact-materialize' });
+    }
+    if (stat.isSymbolicLink() || !stat.isFile()) {
+        throw new errors_1.HarmonyAutolinkingError('UNSAFE_SOURCE_ARTIFACT', 'Harmony HAR must be a regular non-symlink file.', { packageName, stage: 'artifact-materialize' });
+    }
+    const [realRoot, realTarget] = await Promise.all([
+        fs.promises.realpath(root),
+        fs.promises.realpath(target),
+    ]);
+    if (!(0, values_1.isPathInside)(realRoot, realTarget)) {
+        throw new errors_1.HarmonyAutolinkingError('UNSAFE_SOURCE_ARTIFACT', 'Harmony HAR resolves outside its expected package or project root.', { packageName, stage: 'artifact-materialize' });
+    }
+    return stat.size > 0;
+}
+async function validateBundledArtifactsAsync(options) {
+    const harPaths = [...new Set([
+            ...options.rnoh.harPaths,
+            ...(options.arkTs ? [options.arkTs.harPath] : []),
+        ])].sort(values_1.compareText);
+    for (const relative of harPaths) {
+        const harPath = path.resolve(options.packageRoot, relative);
+        if (!await isNonEmptyRegularHarAsync(harPath, options.packageRoot, options.packageName)) {
+            materializationError('SOURCE_ARTIFACT_NOT_PUBLISHED', `${options.packageName} has a missing or empty Harmony HAR.`, options, { harPath: relative });
+        }
+    }
+    return { kind: 'bundled', harPaths };
+}
+async function materializeModuleArtifactAsync(options) {
+    const localArkTs = options.source === 'nativeModulesDir' && options.arkTs;
+    if (!localArkTs && (options.rnoh.harPaths.length > 0
+        || options.arkTs)) {
+        return validateBundledArtifactsAsync(options);
+    }
+    if (!localArkTs) {
+        return { kind: 'bundled', harPaths: [] };
+    }
+    const packageRoot = await fs.promises.realpath(options.packageRoot);
+    const sourceRoot = await (0, values_1.resolveInsideAsync)(packageRoot, HarmonyProjectPath, 'Harmony source project', {
+        packageName: options.packageName,
+        type: 'directory',
+    });
+    const outputPath = await (0, values_1.resolveInsideAsync)(sourceRoot, HarmonyBuildOutputPath, 'Harmony build output', {
+        packageName: options.packageName,
+        mustExist: false,
+    });
+    return {
+        kind: 'local-source',
+        outputPath,
+        materialized: false,
+        build: createFixedHvigorBuildDescriptor(sourceRoot, options.buildType),
+    };
+}
+function appendBounded(current, chunk, limit) {
+    if (current.length >= limit)
+        return current;
+    return current + chunk.toString('utf8').slice(0, limit - current.length);
+}
+function fixedLocalSourceBuildSteps(build) {
+    return [
+        {
+            id: 'ohpm-install',
+            label: 'OHPM dependency install',
+            executable: 'ohpm',
+            cwd: build.cwd,
+            args: ['install', '--all'],
+        },
+        {
+            id: 'hvigor-build',
+            label: 'Hvigor build',
+            ...build,
+        },
+    ];
+}
+function resolveFixedBuildStep(step, env) {
+    if (step.id === 'ohpm-install') {
+        return env.HARMONY_OHPM ? { ...step, executable: env.HARMONY_OHPM } : step;
+    }
+    const configured = env.HARMONY_HVIGORW;
+    if (configured) {
+        return /\.(?:c|m)?js$/iu.test(configured)
+            ? { ...step, executable: env.HARMONY_NODE || process.execPath, args: [configured, ...step.args] }
+            : { ...step, executable: configured };
+    }
+    return step;
+}
+async function runFixedBuildStepAsync(step, packageName, options) {
+    const timeoutMs = options.timeoutMs ?? DefaultBuildTimeoutMs;
+    const outputLimit = options.outputLimit ?? DefaultOutputLimit;
+    const stage = `artifact-materialize:${step.id}`;
+    const env = { ...process.env, ...options.env };
+    const resolvedStep = resolveFixedBuildStep(step, env);
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0
+        || !Number.isInteger(outputLimit) || outputLimit <= 0) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'timeoutMs and outputLimit must be positive integers.', { packageName, stage });
+    }
+    const result = await new Promise((resolve, reject) => {
+        let output = '';
+        let timedOut = false;
+        let settled = false;
+        let killTimer;
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)(resolvedStep.executable, [...resolvedStep.args], {
+                cwd: step.cwd,
+                env,
+                shell: false,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch (cause) {
+            reject(cause);
+            return;
+        }
+        child.stdout.on('data', (chunk) => {
+            output = appendBounded(output, chunk, outputLimit);
+        });
+        child.stderr.on('data', (chunk) => {
+            output = appendBounded(output, chunk, outputLimit);
+        });
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            killTimer = setTimeout(() => child.kill('SIGKILL'), 1_000);
+            killTimer.unref?.();
+        }, timeoutMs);
+        timeout.unref?.();
+        child.on('error', (cause) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (killTimer)
+                clearTimeout(killTimer);
+            reject(cause);
+        });
+        child.on('close', (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolve({ code, signal, output, timedOut });
+        });
+    }).catch((cause) => {
+        throw new errors_1.HarmonyAutolinkingError('SOURCE_BUILD_FAILED', `Unable to execute the fixed ${step.label} for local Harmony source at ${step.cwd}.`, { cause, packageName, stage });
+    });
+    if (result.code !== 0 || result.signal || result.timedOut) {
+        const reason = result.timedOut
+            ? 'timed out'
+            : result.signal ? `was terminated by ${result.signal}` : `exited with code ${result.code}`;
+        const output = (0, values_1.sanitizeOutput)(result.output, [step.cwd], outputLimit);
+        throw new errors_1.HarmonyAutolinkingError('SOURCE_BUILD_FAILED', `Fixed ${step.label} ${reason}${output ? `: ${output}` : '.'}`, { packageName, stage });
+    }
+}
+async function materializeLocalSourceAsync(options) {
+    const module = options.module;
+    if (module.source !== 'nativeModulesDir' || module.artifact.kind !== 'local-source') {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `${module.packageName} is not a nativeModulesDir local-source module.`, { packageName: module.packageName, stage: 'artifact-materialize' });
+    }
+    const artifact = module.artifact;
+    const projectRoot = await fs.promises.realpath(options.projectRoot);
+    const packageRoot = await fs.promises.realpath(module.packageRoot);
+    if (!(0, values_1.isPathInside)(projectRoot, packageRoot)) {
+        throw new errors_1.HarmonyAutolinkingError('UNSAFE_SOURCE_ARTIFACT', 'Harmony local modules must live inside the application project root.', { packageName: module.packageName, stage: 'artifact-materialize' });
+    }
+    if (!module.arkTs) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${module.packageName} local-source descriptor has no derived ArkTS package.`, { packageName: module.packageName, stage: 'artifact-materialize' });
+    }
+    const harPath = await (0, values_1.resolveInsideAsync)(packageRoot, module.arkTs.harPath, 'Harmony materialized HAR path', { packageName: module.packageName, mustExist: false });
+    for (const step of fixedLocalSourceBuildSteps(artifact.build)) {
+        await runFixedBuildStepAsync(step, module.packageName, options);
+    }
+    const outputReady = await isNonEmptyRegularHarAsync(artifact.outputPath, artifact.build.cwd, module.packageName);
+    if (!outputReady) {
+        throw new errors_1.HarmonyAutolinkingError('SOURCE_BUILD_FAILED', `Hvigor did not produce a non-empty HAR at ${(0, values_1.normalizeSlashes)(path.relative(packageRoot, artifact.outputPath))}.`, { packageName: module.packageName, stage: 'artifact-materialize' });
+    }
+    await (0, publish_1.publishArtifactsAsync)({
+        allowedRoot: projectRoot,
+        lockPath: path.join(projectRoot, '.expo/harmony/module-materialize.lock'),
+        files: [{ source: artifact.outputPath, target: harPath }],
+    });
+    if (!await isNonEmptyRegularHarAsync(harPath, packageRoot, module.packageName)) {
+        throw new errors_1.HarmonyAutolinkingError('SOURCE_BUILD_FAILED', 'Harmony HAR materialization produced a missing or empty file.', { packageName: module.packageName, stage: 'artifact-materialize' });
+    }
+    return {
+        packageName: module.packageName,
+        harPath,
+    };
+}
+async function materializeLocalSourcesAsync(modules, options) {
+    const results = [];
+    for (const module of [...modules].sort((left, right) => (0, values_1.compareText)(left.packageName, right.packageName))) {
+        results.push(await materializeLocalSourceAsync({ ...options, module }));
+    }
+    return results;
+}

package/build/src/harmony/ohpm/dependencies.d.ts

@@ -0,0 +1,7 @@
+declare function collectOhpmDeps(descriptors: any): any[];
+declare function resolveOhpmSpecifier(descriptor: any, mapping: any, options?: {
+    harmonyProjectPath?: string;
+    nodeModulesPath?: string;
+}): any;
+declare function normalizeLocalOhpmSpecifier(specifier: any): any;
+export { collectOhpmDeps, resolveOhpmSpecifier, normalizeLocalOhpmSpecifier, };

package/build/src/harmony/ohpm/dependencies.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectOhpmDeps = collectOhpmDeps;
+exports.resolveOhpmSpecifier = resolveOhpmSpecifier;
+exports.normalizeLocalOhpmSpecifier = normalizeLocalOhpmSpecifier;
+const node_path_1 = __importDefault(require("node:path"));
+const packageMetadata_1 = require("../rnoh/packageMetadata");
+const values_1 = require("../../utilities/values");
+function collectOhpmDeps(descriptors) {
+    const dependencies = new Map();
+    for (const descriptor of descriptors) {
+        if (!descriptor.arkTs)
+            continue;
+        dependencies.set(descriptor.arkTs.ohPackageName, {
+            descriptor,
+            mapping: {
+                harPath: descriptor.arkTs.harPath,
+                ohPackageName: descriptor.arkTs.ohPackageName,
+            },
+        });
+    }
+    for (const descriptor of descriptors.filter(item => item.rnoh.harPaths.length > 0)) {
+        for (const mapping of (0, packageMetadata_1.resolveRnohMetadata)(descriptor).harMappings) {
+            dependencies.set(mapping.ohPackageName, { descriptor, mapping });
+        }
+    }
+    return [...dependencies.values()].sort((left, right) => {
+        return left.mapping.ohPackageName.localeCompare(right.mapping.ohPackageName, 'en');
+    });
+}
+function resolveOhpmSpecifier(descriptor, mapping, options = {}) {
+    if (options.harmonyProjectPath) {
+        const packageRoot = options.nodeModulesPath
+            ? node_path_1.default.join(options.nodeModulesPath, ...descriptor.packageName.split('/'))
+            : descriptor.packageLinkPath;
+        const target = node_path_1.default.join(packageRoot, ...mapping.harPath.split('/'));
+        const relative = (0, values_1.normalizeSlashes)(node_path_1.default.relative(options.harmonyProjectPath, target));
+        return relative.startsWith('.') ? relative : `./${relative}`;
+    }
+    return mapping.version || descriptor.packageVersion;
+}
+function normalizeLocalOhpmSpecifier(specifier) {
+    if (typeof specifier !== 'string' || !specifier)
+        return null;
+    if (node_path_1.default.isAbsolute(specifier) || node_path_1.default.win32.isAbsolute(specifier) || !/^\.\.?[\\/]/u.test(specifier)) {
+        return null;
+    }
+    return (0, values_1.normalizeSlashes)(specifier);
+}

package/build/src/harmony/persistence/canonicalize.d.ts

@@ -0,0 +1,15 @@
+import type { CanonicalizeAutolinkingArtifactsOptions, CanonicalizedAutolinkingArtifacts, Manifest } from '../../types';
+interface CanonicalizeOhpmManifestOptions {
+    previousManagedOhpmPackageNames?: ReadonlyArray<string>;
+    requireManagedEntries?: boolean;
+    harmonyProjectPath?: string;
+    nodeModulesPath?: string;
+    errorCode?: string;
+    stage?: string;
+}
+declare function canonicalizeOhpmManifest(source: string, manifest: Manifest, options?: CanonicalizeOhpmManifestOptions): {
+    manifest: Readonly<Record<string, unknown>>;
+    source: string;
+};
+declare function canonicalizeAutolinkingArtifacts(options: CanonicalizeAutolinkingArtifactsOptions): CanonicalizedAutolinkingArtifacts;
+export { canonicalizeAutolinkingArtifacts, canonicalizeOhpmManifest, };

package/build/src/harmony/persistence/canonicalize.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalizeAutolinkingArtifacts = canonicalizeAutolinkingArtifacts;
+exports.canonicalizeOhpmManifest = canonicalizeOhpmManifest;
+const node_path_1 = __importDefault(require("node:path"));
+const json5_1 = __importDefault(require("json5"));
+const errors_1 = require("../../errors");
+const manifest_1 = require("../manifest");
+const values_1 = require("../../utilities/values");
+function requireProjectRoot(value, field) {
+    if (typeof value !== 'string' || !node_path_1.default.isAbsolute(value)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `${field} must be an absolute path.`, { stage: 'canonicalization' });
+    }
+    return node_path_1.default.resolve(value);
+}
+function rebaseProjectPath(value, fromRoot, toRoot) {
+    if (!node_path_1.default.isAbsolute(value) || !(0, values_1.isPathInside)(fromRoot, value))
+        return value;
+    return node_path_1.default.join(toRoot, node_path_1.default.relative(fromRoot, value));
+}
+function canonicalizeAutolinkingManifest(manifest, options) {
+    const generatedProjectRoot = requireProjectRoot(options.generatedProjectRoot, 'generatedProjectRoot');
+    const canonicalProjectRoot = requireProjectRoot(options.canonicalProjectRoot, 'canonicalProjectRoot');
+    const validated = (0, manifest_1.validateManifest)(manifest);
+    const canonical = {
+        ...validated,
+        modules: validated.modules.map(module => ({
+            ...module,
+            packageRoot: rebaseProjectPath(module.packageRoot, generatedProjectRoot, canonicalProjectRoot),
+            packageLinkPath: rebaseProjectPath(module.packageLinkPath, generatedProjectRoot, canonicalProjectRoot),
+        })),
+    };
+    return {
+        manifest: canonical,
+        source: (0, values_1.stringifyJson)(canonical),
+    };
+}
+function canonicalizeOhpmManifest(source, manifest, options = {}) {
+    const errorCode = options.errorCode || 'INVALID_OPTIONS';
+    const stage = options.stage || 'canonicalization';
+    let candidate;
+    try {
+        candidate = json5_1.default.parse(source);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError(errorCode, 'harmony/oh-package.json5 must contain a JSON5 object.', { cause, stage });
+    }
+    if (!(0, values_1.isObject)(candidate)) {
+        throw new errors_1.HarmonyAutolinkingError(errorCode, 'harmony/oh-package.json5 must contain a JSON5 object.', { stage });
+    }
+    for (const field of ['dependencies', 'overrides']) {
+        if (candidate[field] !== undefined && !(0, values_1.isObject)(candidate[field])) {
+            throw new errors_1.HarmonyAutolinkingError(errorCode, `harmony/oh-package.json5 ${field} must be an object.`, { stage });
+        }
+    }
+    const specifiers = (0, manifest_1.ohpmDependenciesFromManifest)(manifest, {
+        harmonyProjectPath: options.harmonyProjectPath,
+        nodeModulesPath: options.nodeModulesPath,
+    });
+    const currentNames = Object.keys(specifiers).sort((left, right) => left.localeCompare(right, 'en'));
+    const managedNames = new Set([
+        ...(options.previousManagedOhpmPackageNames || []),
+        ...currentNames,
+    ]);
+    if (options.requireManagedEntries) {
+        for (const field of ['dependencies', 'overrides']) {
+            if (!(0, values_1.isObject)(candidate[field])) {
+                throw new errors_1.HarmonyAutolinkingError(errorCode, `harmony/oh-package.json5 ${field} must be an object.`, { stage });
+            }
+            for (const packageName of currentNames) {
+                if (!Object.hasOwn(candidate[field], packageName)) {
+                    throw new errors_1.HarmonyAutolinkingError(errorCode, `RNOH omitted the managed ${field} entry for ${packageName}.`, { stage, details: { packageName, field } });
+                }
+            }
+        }
+    }
+    for (const field of ['dependencies', 'overrides']) {
+        const values = { ...(candidate[field] || {}) };
+        for (const packageName of managedNames)
+            delete values[packageName];
+        for (const packageName of currentNames)
+            values[packageName] = specifiers[packageName];
+        candidate[field] = values;
+    }
+    return {
+        manifest: candidate,
+        source: `${json5_1.default.stringify(candidate, null, 2)}\n`,
+    };
+}
+function canonicalizeAutolinkingArtifacts(options) {
+    let parsedManifest;
+    try {
+        parsedManifest = JSON.parse(options.manifestSource);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_MANIFEST', 'Harmony autolinking manifest must contain valid JSON.', { cause, stage: 'canonicalization' });
+    }
+    const canonicalManifest = canonicalizeAutolinkingManifest(parsedManifest, options);
+    const canonicalOhpm = canonicalizeOhpmManifest(options.ohPackageSource, canonicalManifest.manifest, { requireManagedEntries: true, harmonyProjectPath: options.harmonyProjectPath });
+    return {
+        manifest: canonicalManifest.manifest,
+        manifestSource: canonicalManifest.source,
+        ohPackageSource: canonicalOhpm.source,
+    };
+}

package/build/src/harmony/providers/host.d.ts

@@ -0,0 +1,3 @@
+declare function moduleRegistrationId(ohPackageName: any, moduleClass: any): string;
+declare function renderArkTsHostProviderSource(descriptors: any): string;
+export { moduleRegistrationId, renderArkTsHostProviderSource, };

package/build/src/harmony/providers/host.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleRegistrationId = moduleRegistrationId;
+exports.renderArkTsHostProviderSource = renderArkTsHostProviderSource;
+const errors_1 = require("../../errors");
+const host_1 = require("../../metadata/host");
+function collectHostExtensions(descriptors) {
+    const collected = Object.fromEntries(host_1.HostMetadataFields.map(field => [field, []]));
+    for (const descriptor of [...descriptors].sort((left, right) => (left.packageName.localeCompare(right.packageName, 'en')))) {
+        const declarations = host_1.HostMetadataFields.flatMap(field => descriptor.expo[field] || []);
+        if (declarations.length === 0)
+            continue;
+        const name = descriptor.arkTs?.ohPackageName;
+        if (!name) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'Harmony host extension classes must be exported by the module primary HAR.', { packageName: descriptor.packageName, stage: 'generate-host-provider' });
+        }
+        for (const field of host_1.HostMetadataFields) {
+            for (const className of descriptor.expo[field] || []) {
+                collected[field].push({ className, ohPackageName: name, packageName: descriptor.packageName });
+            }
+        }
+    }
+    return collected;
+}
+function moduleRegistrationId(ohPackageName, moduleClass) {
+    return `${ohPackageName}:${moduleClass}`;
+}
+function collectArkTsModuleRegistrations(descriptors) {
+    const registrations = [];
+    for (const descriptor of [...descriptors].sort((left, right) => (left.packageName.localeCompare(right.packageName, 'en')))) {
+        if (descriptor.harmony.modules.length === 0)
+            continue;
+        const arkTs = descriptor.arkTs;
+        if (!arkTs) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'Harmony ArkTS modules require the conventional Harmony library package.', { packageName: descriptor.packageName, stage: 'generate-host-provider' });
+        }
+        for (const moduleClass of descriptor.harmony.modules) {
+            registrations.push({
+                moduleClass,
+                ohPackageName: arkTs.ohPackageName,
+                packageName: descriptor.packageName,
+                registrationId: moduleRegistrationId(arkTs.ohPackageName, moduleClass),
+            });
+        }
+    }
+    return registrations;
+}
+function renderArkTsHostProviderSource(descriptors) {
+    const extensions = collectHostExtensions(descriptors);
+    const registrations = collectArkTsModuleRegistrations(descriptors);
+    const imports = new Map();
+    for (const field of host_1.HostMetadataFields) {
+        for (const extension of extensions[field]) {
+            const key = `${extension.ohPackageName}\0${extension.className}`;
+            if (!imports.has(key)) {
+                imports.set(key, {
+                    ...extension,
+                    alias: `ExpoHarmonyHostExtension${imports.size}`,
+                });
+            }
+            extension.alias = imports.get(key).alias;
+        }
+    }
+    const lines = [
+        '/**',
+        ' * Automatically generated by @expo-harmony/expo-modules-autolinking.',
+        ' */',
+        '',
+    ];
+    lines.push(`import { ExpoHarmonyHostState } from '@expo-harmony/expo-modules-core/Autolinking';`, 'import type {', '  ExpoHarmonyHostProvider,', ...(registrations.length > 0 ? ['  ExpoModuleContext,'] : []), '  ExpoModuleRegistration,', `} from '@expo-harmony/expo-modules-core/Autolinking';`);
+    registrations.forEach((registration, index) => {
+        registration.alias = `ExpoHarmonyModule${index}`;
+        lines.push(`import { ${registration.moduleClass} as ${registration.alias} } from '${registration.ohPackageName}';`);
+    });
+    for (const extension of imports.values()) {
+        lines.push(`import { ${extension.className} as ${extension.alias} } from '${extension.ohPackageName}';`);
+    }
+    lines.push('', 'class GeneratedExpoHarmonyHostProvider implements ExpoHarmonyHostProvider {', '  readonly hostState: ExpoHarmonyHostState = new ExpoHarmonyHostState();', '', '  readonly expoModules: ExpoModuleRegistration[] = [');
+    for (const registration of registrations) {
+        lines.push('    {', `      registrationId: ${JSON.stringify(registration.registrationId)},`, `      moduleClassName: ${JSON.stringify(registration.moduleClass)},`, `      factory: (context: ExpoModuleContext) => new ${registration.alias}(context),`, '    },');
+    }
+    lines.push('  ];', '}', '', 'export const expoHarmonyHostProvider: ExpoHarmonyHostProvider =', '  new GeneratedExpoHarmonyHostProvider();', '', '@Builder', 'export function ExpoHarmonyRootView(): void {');
+    for (const extension of extensions.rootViewComponents) {
+        lines.push(`  ${extension.alias}()`);
+    }
+    lines.push('}', '');
+    return lines.join('\n');
+}

package/build/src/harmony/rnoh/cli.d.ts

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

package/build/src/harmony/rnoh/cli.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCliAsync = resolveCliAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("../../config/constants");
+const errors_1 = require("../../errors");
+const values_1 = require("../../utilities/values");
+function findPackageJson(projectRoot, packageName) {
+    try {
+        return (0, values_1.resolvePackageFromProject)(projectRoot, `${packageName}/package.json`);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `${constants_1.RnohCliPackage} is not installed.`, {
+            cause,
+            stage: 'rnoh-preflight',
+        });
+    }
+}
+async function resolveCliAsync(cliOptions) {
+    const projectRoot = await (0, values_1.realpathExistingAsync)(cliOptions.projectRoot, {
+        type: 'directory',
+        field: 'projectRoot',
+        stage: 'rnoh-preflight',
+    });
+    const raw = cliOptions.rnohCliPackageJsonPath
+        || findPackageJson(projectRoot, constants_1.RnohCliPackage);
+    const pkg = await (0, values_1.realpathExistingAsync)(raw, {
+        type: 'file',
+        code: 'RNOH_CLI_NOT_FOUND',
+        field: 'RNOH CLI package.json',
+        stage: 'rnoh-preflight',
+    });
+    const packageJson = await (0, values_1.readJsonAsync)(pkg, 'RNOH_CLI_NOT_FOUND', 'rnoh-preflight');
+    if (packageJson.name !== constants_1.RnohCliPackage) {
+        throw new errors_1.HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `Expected ${constants_1.RnohCliPackage}, found ${String(packageJson.name)}.`, { stage: 'rnoh-preflight' });
+    }
+    const pluginRoot = node_path_1.default.dirname(pkg);
+    const pluginConfig = node_path_1.default.join(pluginRoot, 'react-native.config.js');
+    if (!node_fs_1.default.existsSync(pluginConfig)) {
+        throw new errors_1.HarmonyAutolinkingError('RNOH_CLI_NOT_FOUND', `${constants_1.RnohCliPackage} does not expose its public React Native CLI plugin config.`, { stage: 'rnoh-preflight' });
+    }
+    const exec = cliOptions.reactNativeExecutable
+        || node_path_1.default.join(cliOptions.nodeModulesPath || node_path_1.default.join(projectRoot, 'node_modules'), '.bin', 'react-native');
+    const executable = await (0, values_1.realpathExistingAsync)(exec, {
+        type: 'file',
+        code: 'RNOH_CLI_NOT_FOUND',
+        field: 'project-local react-native executable',
+        stage: 'rnoh-preflight',
+    });
+    return executable;
+}

package/build/src/harmony/rnoh/link.d.ts

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