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

package/build/src/harmony/transaction/publish.d.ts

@@ -0,0 +1,6 @@
+declare function publishArtifactsAsync(options: any): Promise<{
+    changed: any[];
+    unchanged: any[];
+    warnings: any[];
+}>;
+export { publishArtifactsAsync, };

package/build/src/harmony/transaction/publish.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishArtifactsAsync = publishArtifactsAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../../errors");
+const values_1 = require("../../utilities/values");
+const MALFORMED_LOCK_GRACE_MS = 30_000;
+async function processIsAliveAsync(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (cause) {
+        return cause.code !== 'ESRCH';
+    }
+}
+async function removeStaleLockAsync(lockPath) {
+    let observed;
+    try {
+        observed = await node_fs_1.default.promises.lstat(lockPath);
+        if (!observed.isFile() || observed.isSymbolicLink())
+            return false;
+    }
+    catch (_cause) {
+        return false;
+    }
+    let contents;
+    try {
+        contents = JSON.parse(await node_fs_1.default.promises.readFile(lockPath, 'utf8'));
+    }
+    catch (_cause) {
+        if (Date.now() - observed.mtimeMs < MALFORMED_LOCK_GRACE_MS)
+            return false;
+        contents = null;
+    }
+    if (contents && await processIsAliveAsync(contents.pid))
+        return false;
+    try {
+        const current = await node_fs_1.default.promises.lstat(lockPath);
+        if (current.dev !== observed.dev || current.ino !== observed.ino
+            || current.mtimeMs !== observed.mtimeMs || current.size !== observed.size) {
+            return false;
+        }
+        await node_fs_1.default.promises.unlink(lockPath);
+        return true;
+    }
+    catch (_cause) {
+        return false;
+    }
+}
+async function releasePublishLockAsync(handle, lockPath) {
+    let owned;
+    try {
+        owned = await handle.stat();
+    }
+    catch (_cause) {
+        // Closing the descriptor is still required even if its metadata is unavailable.
+    }
+    await handle.close().catch(() => { });
+    if (!owned)
+        return false;
+    try {
+        const current = await node_fs_1.default.promises.lstat(lockPath);
+        if (current.dev !== owned.dev || current.ino !== owned.ino)
+            return false;
+        await node_fs_1.default.promises.unlink(lockPath);
+        return true;
+    }
+    catch (_cause) {
+        return false;
+    }
+}
+async function acquirePublishLockAsync(lockPath) {
+    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(lockPath), { recursive: true });
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            const handle = await node_fs_1.default.promises.open(lockPath, 'wx', 0o600);
+            try {
+                await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }));
+                await handle.sync();
+                return handle;
+            }
+            catch (cause) {
+                await releasePublishLockAsync(handle, lockPath);
+                throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', 'Unable to initialize the Harmony autolinking publish lock.', { cause, stage: 'publish' });
+            }
+        }
+        catch (cause) {
+            if (cause.code === 'EEXIST' && attempt === 0 && await removeStaleLockAsync(lockPath))
+                continue;
+            if (cause.code === 'EEXIST') {
+                throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', 'Another Harmony autolinking publish is in progress.', { cause, stage: 'publish' });
+            }
+            throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', 'Unable to acquire the Harmony autolinking lock.', { cause, stage: 'publish' });
+        }
+    }
+    throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', 'Unable to acquire the Harmony autolinking lock.', { stage: 'publish' });
+}
+function assertLexicallyContained(target, allowedRoot) {
+    const resolved = node_path_1.default.resolve(target);
+    const absoluteRoot = node_path_1.default.resolve(allowedRoot);
+    if (!(0, values_1.isPathInside)(absoluteRoot, resolved)) {
+        throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', `Publish target escapes the allowed root: ${resolved}`, { stage: 'publish' });
+    }
+    if (resolved.split(node_path_1.default.sep).includes('node_modules')) {
+        throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', 'Publishing into node_modules is forbidden.', { stage: 'publish' });
+    }
+    return resolved;
+}
+async function assertSafeTargetAsync(target, allowedRoot) {
+    const resolved = assertLexicallyContained(target, allowedRoot);
+    const absoluteRoot = node_path_1.default.resolve(allowedRoot);
+    if (await (0, values_1.pathExistsAsync)(resolved)) {
+        const stat = await node_fs_1.default.promises.lstat(resolved);
+        if (stat.isSymbolicLink()) {
+            throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', `Publish target must not be a symbolic link: ${resolved}`, { stage: 'publish' });
+        }
+    }
+    if (await (0, values_1.pathExistsAsync)(absoluteRoot)) {
+        const realRoot = await node_fs_1.default.promises.realpath(absoluteRoot);
+        let ancestor = node_path_1.default.dirname(resolved);
+        while (!(await (0, values_1.pathExistsAsync)(ancestor))) {
+            const parent = node_path_1.default.dirname(ancestor);
+            if (parent === ancestor)
+                break;
+            ancestor = parent;
+        }
+        const realAncestor = await node_fs_1.default.promises.realpath(ancestor);
+        if (!(0, values_1.isPathInside)(realRoot, realAncestor)) {
+            throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', `Publish target resolves outside the allowed root: ${resolved}`, { stage: 'publish' });
+        }
+    }
+    return resolved;
+}
+async function stageFileAsync(file, stagedTarget) {
+    if ((file.source === undefined) === (file.content === undefined)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'Each publish file needs exactly one source or content.', { stage: 'publish' });
+    }
+    if (file.source !== undefined) {
+        await node_fs_1.default.promises.copyFile(file.source, stagedTarget);
+    }
+    else {
+        if (typeof file.content !== 'string' && !Buffer.isBuffer(file.content)) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'Publish file content must be a string or Buffer.', { stage: 'publish' });
+        }
+        await node_fs_1.default.promises.writeFile(stagedTarget, file.content, file.mode ? { mode: file.mode } : undefined);
+    }
+}
+async function filesEqualAsync(left, right) {
+    if (!(await (0, values_1.pathExistsAsync)(left)) || !(await (0, values_1.pathExistsAsync)(right)))
+        return false;
+    const [leftBuffer, rightBuffer] = await Promise.all([
+        node_fs_1.default.promises.readFile(left),
+        node_fs_1.default.promises.readFile(right),
+    ]);
+    return leftBuffer.equals(rightBuffer);
+}
+async function removeEmptyParentsAsync(directory, stopAt) {
+    let current = directory;
+    while ((0, values_1.isPathInside)(stopAt, current) && current !== stopAt) {
+        try {
+            await node_fs_1.default.promises.rmdir(current);
+        }
+        catch (_cause) {
+            break;
+        }
+        current = node_path_1.default.dirname(current);
+    }
+}
+async function publishArtifactsAsync(options) {
+    if (!Array.isArray(options?.files) || options.files.length === 0) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'A publish transaction requires at least one file.', { stage: 'publish' });
+    }
+    if (typeof options.allowedRoot !== 'string' || !options.allowedRoot) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'A publish transaction requires allowedRoot.', { stage: 'publish' });
+    }
+    const allowedRoot = node_path_1.default.resolve(options.allowedRoot);
+    const files = [];
+    for (const file of options.files) {
+        if (!file || typeof file.target !== 'string' || !file.target) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'Publish file target must be a non-empty string.', { stage: 'publish' });
+        }
+        files.push({ ...file, target: await assertSafeTargetAsync(file.target, allowedRoot) });
+    }
+    if (new Set(files.map(file => file.target)).size !== files.length) {
+        throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', 'A publish transaction contains duplicate targets.', { stage: 'publish' });
+    }
+    const stale = [];
+    for (const target of options.stale || []) {
+        const safeTarget = await assertSafeTargetAsync(target, allowedRoot);
+        if (!files.some(file => file.target === safeTarget) && !stale.includes(safeTarget))
+            stale.push(safeTarget);
+    }
+    const lockPath = await assertSafeTargetAsync(options.lockPath || node_path_1.default.join(allowedRoot, '.expo-harmony-autolinking.lock'), allowedRoot);
+    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(lockPath), { recursive: true });
+    const tmp = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_path_1.default.dirname(lockPath), '.expo-harmony-publish-'));
+    const prepared = [];
+    let lockHandle;
+    const touched = [];
+    const changed = [];
+    const unchanged = [];
+    try {
+        for (let index = 0; index < files.length; index += 1) {
+            const staged = node_path_1.default.join(tmp, `new-${index}`);
+            await stageFileAsync(files[index], staged);
+            prepared.push({ ...files[index], staged });
+        }
+        lockHandle = await acquirePublishLockAsync(lockPath);
+        for (let index = 0; index < prepared.length; index += 1) {
+            const file = prepared[index];
+            if (await filesEqualAsync(file.staged, file.target)) {
+                unchanged.push(file.target);
+                continue;
+            }
+            const existed = await (0, values_1.pathExistsAsync)(file.target);
+            const backup = existed ? node_path_1.default.join(tmp, `backup-${index}`) : null;
+            if (backup)
+                await node_fs_1.default.promises.copyFile(file.target, backup);
+            touched.push({ target: file.target, existed, backup });
+            await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(file.target), { recursive: true });
+            await node_fs_1.default.promises.rename(file.staged, file.target);
+            if (file.mode)
+                await node_fs_1.default.promises.chmod(file.target, file.mode);
+            changed.push(file.target);
+        }
+        for (let index = 0; index < stale.length; index += 1) {
+            const target = stale[index];
+            if (!(await (0, values_1.pathExistsAsync)(target)))
+                continue;
+            const backup = node_path_1.default.join(tmp, `stale-${index}`);
+            await node_fs_1.default.promises.copyFile(target, backup);
+            touched.push({ target, existed: true, backup });
+            await node_fs_1.default.promises.unlink(target);
+            changed.push(target);
+        }
+        return { changed, unchanged, warnings: [] };
+    }
+    catch (cause) {
+        const failures = [];
+        for (const entry of [...touched].reverse()) {
+            try {
+                if (entry.existed) {
+                    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(entry.target), { recursive: true });
+                    await node_fs_1.default.promises.copyFile(entry.backup, entry.target);
+                }
+                else if (await (0, values_1.pathExistsAsync)(entry.target)) {
+                    await node_fs_1.default.promises.unlink(entry.target);
+                    await removeEmptyParentsAsync(node_path_1.default.dirname(entry.target), allowedRoot);
+                }
+            }
+            catch (error) {
+                failures.push({ target: entry.target, message: error.message });
+            }
+        }
+        throw new errors_1.HarmonyAutolinkingError('PUBLISH_FAILED', 'Harmony autolinking publish failed and was rolled back.', {
+            cause,
+            details: failures.length > 0 ? { rollbackFailures: failures } : undefined,
+            stage: 'publish',
+        });
+    }
+    finally {
+        if (lockHandle)
+            await releasePublishLockAsync(lockHandle, lockPath);
+        await node_fs_1.default.promises.rm(tmp, { recursive: true, force: true }).catch(() => { });
+    }
+}

package/build/src/harmony/transaction/stageProject.d.ts

@@ -0,0 +1,18 @@
+declare function stageProjectAsync(options: any): Promise<{
+    projectRoot: string;
+    harmonyProjectPath: string;
+    sourceNodeModulesPath: string;
+    nodeModulesPath: string;
+    rnohRuntimePackages: any[];
+    temporaryRoot: string;
+    stageProjectRoot: string;
+    stageHarmonyProjectPath: string;
+}>;
+declare function cleanupStagingProjectAsync(staging: any): Promise<{
+    severity: string;
+    code: string;
+    message: string;
+    stage: string;
+    cause: any;
+}>;
+export { cleanupStagingProjectAsync, stageProjectAsync, };

package/build/src/harmony/transaction/stageProject.js

@@ -0,0 +1,313 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupStagingProjectAsync = cleanupStagingProjectAsync;
+exports.stageProjectAsync = stageProjectAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const json5_1 = __importDefault(require("json5"));
+const constants_1 = require("../../config/constants");
+const errors_1 = require("../../errors");
+const generate_1 = require("../manifest/generate");
+const dependencies_1 = require("../ohpm/dependencies");
+const canonicalize_1 = require("../persistence/canonicalize");
+const values_1 = require("../../utilities/values");
+async function findLocalOhpmDepsAsync(content, harmony) {
+    let dependencies;
+    try {
+        const parsed = json5_1.default.parse(content);
+        dependencies = parsed && typeof parsed.dependencies === 'object' && !Array.isArray(parsed.dependencies)
+            ? parsed.dependencies
+            : {};
+    }
+    catch (_cause) {
+        return [];
+    }
+    const result = [];
+    for (const [name, specifier] of Object.entries(dependencies)) {
+        const relative = (0, dependencies_1.normalizeLocalOhpmSpecifier)(specifier);
+        if (!relative)
+            continue;
+        const harPath = node_path_1.default.resolve(harmony, relative);
+        if (!(await (0, values_1.pathExistsAsync)(harPath)))
+            continue;
+        const marker = `${node_path_1.default.sep}node_modules${node_path_1.default.sep}`;
+        const markerIndex = harPath.lastIndexOf(marker);
+        if (markerIndex < 0)
+            continue;
+        const rest = harPath.slice(markerIndex + marker.length).split(node_path_1.default.sep);
+        const packageSegments = rest[0]?.startsWith('@') ? rest.slice(0, 2) : rest.slice(0, 1);
+        if (packageSegments.length === 0 || packageSegments.some(segment => !segment))
+            continue;
+        const packageName = packageSegments.join('/');
+        const packageRoot = node_path_1.default.join(harPath.slice(0, markerIndex + marker.length), ...packageSegments);
+        try {
+            const packageJson = JSON.parse(await node_fs_1.default.promises.readFile(node_path_1.default.join(packageRoot, 'package.json'), 'utf8'));
+            if (packageJson.name !== packageName)
+                continue;
+            result.push({
+                ohPackageName: name,
+                packageName,
+                packageRoot: await node_fs_1.default.promises.realpath(packageRoot),
+            });
+        }
+        catch (_cause) {
+            // RNOH would not be able to preserve an unreadable package reference either.
+        }
+    }
+    return result;
+}
+async function findNodeModulesAsync(projectRoot) {
+    let directory = projectRoot;
+    while (true) {
+        const candidate = node_path_1.default.join(directory, 'node_modules');
+        if (await (0, values_1.pathExistsAsync)(candidate))
+            return candidate;
+        const parent = node_path_1.default.dirname(directory);
+        if (parent === directory)
+            return node_path_1.default.join(projectRoot, 'node_modules');
+        directory = parent;
+    }
+}
+function buildRnohMetadata(descriptor) {
+    return {
+        ...(descriptor.rnoh.ohPackageName === undefined
+            ? {}
+            : {
+                ohPackageName: Array.isArray(descriptor.rnoh.ohPackageName)
+                    ? descriptor.rnoh.ohPackageName.map(mapping => ({ ...mapping }))
+                    : descriptor.rnoh.ohPackageName,
+            }),
+        mainHarPath: descriptor.rnoh.mainHarPath,
+        ...(descriptor.rnoh.etsPackageClassName
+            ? { etsPackageClassName: descriptor.rnoh.etsPackageClassName }
+            : {}),
+        ...(descriptor.rnoh.cppPackageClassName
+            ? { cppPackageClassName: descriptor.rnoh.cppPackageClassName }
+            : {}),
+        ...(descriptor.rnoh.cmakeLibraryTargetName
+            ? { cmakeLibraryTargetName: descriptor.rnoh.cmakeLibraryTargetName }
+            : {}),
+    };
+}
+async function stageCuratedPackageAsync(stage, descriptor) {
+    await node_fs_1.default.promises.mkdir(stage, { recursive: true });
+    await node_fs_1.default.promises.writeFile(node_path_1.default.join(stage, 'package.json'), (0, values_1.stringifyJson)({
+        name: descriptor.packageName,
+        version: descriptor.packageVersion,
+        ...(descriptor.rnoh.harPaths.length > 0
+            ? { harmony: { autolinking: buildRnohMetadata(descriptor) } }
+            : {}),
+    }));
+    const harPaths = (0, values_1.sortedUniqueStrings)([
+        ...descriptor.rnoh.harPaths,
+        ...(descriptor.arkTs ? [descriptor.arkTs.harPath] : []),
+    ]);
+    for (const harPath of harPaths) {
+        const source = await (0, values_1.resolveInsideAsync)(descriptor.packageRoot, harPath, 'descriptor HAR path', { packageName: descriptor.packageName, type: 'file' });
+        const destination = node_path_1.default.resolve(stage, ...harPath.split('/'));
+        if (!(0, values_1.isPathInside)(stage, destination)) {
+            throw new errors_1.HarmonyAutolinkingError('PATH_OUTSIDE_PACKAGE', 'A curated HAR path escapes its staging package.', {
+                packageName: descriptor.packageName,
+                stage: 'staging',
+            });
+        }
+        await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(destination), { recursive: true });
+        await node_fs_1.default.promises.copyFile(source, destination, node_fs_1.default.constants.COPYFILE_FICLONE);
+    }
+}
+async function updateOhpmManifestAsync(manifestPath, descriptors, options) {
+    let source;
+    try {
+        source = await node_fs_1.default.promises.readFile(manifestPath, 'utf8');
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'Unable to read harmony/oh-package.json5.', {
+            cause,
+            stage: 'staging',
+        });
+    }
+    const manifest = (0, generate_1.createManifest)(descriptors, { buildType: options.buildType });
+    const canonical = (0, canonicalize_1.canonicalizeOhpmManifest)(source, manifest, {
+        previousManagedOhpmPackageNames: options.previousManagedOhpmPackageNames,
+        harmonyProjectPath: options.harmonyProjectPath,
+        nodeModulesPath: options.nodeModulesPath,
+        stage: 'staging',
+    });
+    await node_fs_1.default.promises.writeFile(manifestPath, canonical.source);
+}
+async function stageProjectAsync(options) {
+    const projectRoot = await (0, values_1.realpathExistingAsync)(options.projectRoot, {
+        type: 'directory',
+        field: 'projectRoot',
+        stage: 'staging',
+    });
+    const harmony = await (0, values_1.realpathExistingAsync)(options.harmonyProjectPath, {
+        type: 'directory',
+        field: 'harmonyProjectPath',
+        stage: 'staging',
+    });
+    if (!(0, values_1.isPathInside)(projectRoot, harmony)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'harmonyProjectPath must be inside projectRoot.', { stage: 'staging' });
+    }
+    const requested = options.nodeModulesPath || await findNodeModulesAsync(projectRoot);
+    const source = await (0, values_1.realpathExistingAsync)(requested, {
+        type: 'directory',
+        field: 'nodeModulesPath',
+        stage: 'staging',
+    });
+    const tmp = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'expo-harmony-autolinking-'));
+    try {
+        const stageRoot = node_path_1.default.join(tmp, 'project');
+        const relative = node_path_1.default.relative(projectRoot, harmony);
+        const stageHarmony = node_path_1.default.join(stageRoot, relative);
+        const modules = node_path_1.default.join(stageRoot, 'node_modules');
+        await node_fs_1.default.promises.mkdir(stageHarmony, { recursive: true });
+        await node_fs_1.default.promises.writeFile(node_path_1.default.join(stageRoot, 'package.json'), (0, values_1.stringifyJson)({
+            name: 'expo-harmony-autolinking-stage',
+            private: true,
+        }));
+        let plugin = `${constants_1.RnohCliPackage}/react-native.config.js`;
+        try {
+            const pkg = options.rnohCliPackageJsonPath
+                ? await node_fs_1.default.promises.realpath(options.rnohCliPackageJsonPath)
+                : (0, values_1.resolvePackageFromProject)(projectRoot, `${constants_1.RnohCliPackage}/package.json`);
+            plugin = await node_fs_1.default.promises.realpath(node_path_1.default.join(node_path_1.default.dirname(pkg), 'react-native.config.js'));
+        }
+        catch (_cause) {
+            // Preflight emits the actionable package/CLI diagnostic. Keeping the public
+            // package request here also lets callers inspect a stage without installing RNOH.
+        }
+        await node_fs_1.default.promises.writeFile(node_path_1.default.join(stageRoot, 'react-native.config.js'), `module.exports = require(${JSON.stringify(plugin)});\n`);
+        const runtime = [];
+        if (options.modules === undefined) {
+            await node_fs_1.default.promises.symlink(source, modules, process.platform === 'win32' ? 'junction' : 'dir');
+        }
+        else {
+            await node_fs_1.default.promises.mkdir(modules, { recursive: true });
+            const staged = options.modules.filter(descriptor => (descriptor.rnoh.harPaths.length > 0 || descriptor.arkTs));
+            for (const descriptor of staged) {
+                const segments = descriptor.packageName.split('/');
+                const validName = segments.length === 1
+                    ? segments[0] && !segments[0].startsWith('@')
+                    : segments.length === 2 && segments[0].startsWith('@') && segments[0].length > 1 && segments[1];
+                if (!validName || segments.some(segment => segment === '.' || segment === '..' || segment.includes('\\'))) {
+                    throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `Invalid npm package name for curated staging: ${descriptor.packageName}`, {
+                        packageName: descriptor.packageName,
+                        stage: 'staging',
+                    });
+                }
+                const stage = node_path_1.default.join(modules, ...segments);
+                await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(stage), { recursive: true });
+                await stageCuratedPackageAsync(stage, descriptor);
+            }
+            const actual = node_path_1.default.join(harmony, constants_1.RnohArtifacts.ohPackage);
+            if (await (0, values_1.pathExistsAsync)(actual)) {
+                const content = await node_fs_1.default.promises.readFile(actual, 'utf8');
+                const previous = new Set(options.previousManagedOhpmPackageNames || []);
+                const verified = new Set(staged.map(item => item.packageName));
+                for (const dependency of await findLocalOhpmDepsAsync(content, harmony)) {
+                    if (previous.has(dependency.ohPackageName))
+                        continue;
+                    if (verified.has(dependency.packageName))
+                        continue;
+                    const target = node_path_1.default.join(modules, ...dependency.packageName.split('/'));
+                    if (!(await (0, values_1.pathExistsAsync)(target))) {
+                        await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(target), { recursive: true });
+                        await node_fs_1.default.promises.symlink(dependency.packageRoot, target, process.platform === 'win32' ? 'junction' : 'dir');
+                    }
+                    runtime.push(dependency.packageName);
+                }
+            }
+            try {
+                const packageName = '@react-native-community/cli';
+                const pkg = (0, values_1.resolvePackageFromProject)(projectRoot, `${packageName}/package.json`);
+                const packageRoot = await node_fs_1.default.promises.realpath(node_path_1.default.dirname(pkg));
+                const target = node_path_1.default.join(modules, ...packageName.split('/'));
+                if (!(await (0, values_1.pathExistsAsync)(target))) {
+                    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(target), { recursive: true });
+                    await node_fs_1.default.promises.symlink(packageRoot, target, process.platform === 'win32' ? 'junction' : 'dir');
+                }
+                runtime.push(packageName);
+            }
+            catch (_cause) {
+                // Explicit/fake executables need not install the React Native wrapper runtime.
+            }
+        }
+        for (const relativePath of Object.values(constants_1.RnohArtifacts)) {
+            await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(node_path_1.default.join(stageHarmony, relativePath)), { recursive: true });
+        }
+        const actual = node_path_1.default.join(harmony, constants_1.RnohArtifacts.ohPackage);
+        const stage = node_path_1.default.join(stageHarmony, constants_1.RnohArtifacts.ohPackage);
+        if (await (0, values_1.pathExistsAsync)(actual)) {
+            const stat = await node_fs_1.default.promises.lstat(actual);
+            if (!stat.isFile() || stat.isSymbolicLink()) {
+                throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'harmony/oh-package.json5 must be a regular file.', { stage: 'staging' });
+            }
+            await node_fs_1.default.promises.copyFile(actual, stage);
+        }
+        else {
+            await node_fs_1.default.promises.writeFile(stage, '{\n  dependencies: {}\n}\n');
+        }
+        if (options.modules !== undefined) {
+            await updateOhpmManifestAsync(stage, options.modules, {
+                buildType: options.buildType,
+                harmonyProjectPath: stageHarmony,
+                nodeModulesPath: modules,
+                previousManagedOhpmPackageNames: options.previousManagedOhpmPackageNames,
+            });
+        }
+        return {
+            projectRoot,
+            harmonyProjectPath: harmony,
+            sourceNodeModulesPath: source,
+            nodeModulesPath: modules,
+            rnohRuntimePackages: runtime,
+            temporaryRoot: tmp,
+            stageProjectRoot: stageRoot,
+            stageHarmonyProjectPath: stageHarmony,
+        };
+    }
+    catch (cause) {
+        let warning;
+        try {
+            await node_fs_1.default.promises.rm(tmp, { recursive: true, force: true });
+        }
+        catch (cleanupCause) {
+            warning = {
+                severity: 'warning',
+                code: 'ERR_EXPO_HARMONY_STAGING_CLEANUP_FAILED',
+                message: 'Unable to remove a partially-created Harmony autolinking staging directory.',
+                stage: 'cleanup',
+                details: { message: cleanupCause.message },
+            };
+        }
+        throw new errors_1.HarmonyAutolinkingError(typeof cause.code === 'string' ? cause.code : 'STAGING_FAILED', cause.message || 'Unable to stage the Harmony project.', {
+            cause,
+            stage: cause.stage || 'staging',
+            packageName: cause.packageName,
+            diagnostics: cause.diagnostics,
+            details: warning
+                ? { ...(cause.details || {}), cleanupWarning: warning }
+                : cause.details,
+        });
+    }
+}
+async function cleanupStagingProjectAsync(staging) {
+    try {
+        await node_fs_1.default.promises.rm(staging.temporaryRoot, { recursive: true, force: true });
+        return null;
+    }
+    catch (cause) {
+        return {
+            severity: 'warning',
+            code: 'ERR_EXPO_HARMONY_STAGING_CLEANUP_FAILED',
+            message: 'Unable to remove the Harmony autolinking staging directory.',
+            stage: 'cleanup',
+            cause,
+        };
+    }
+}

package/build/src/metadata/descriptor.d.ts

@@ -0,0 +1,19 @@
+import type { BuildType, RnohMetadata } from '../types';
+declare function createDescriptorFromSearchRecordAsync(record: any, buildType?: BuildType): Promise<{
+    artifact: import("../types").ModuleArtifactDescriptor;
+    arkTs?: {
+        harPath: string;
+        ohPackageName: any;
+    };
+    packageName: any;
+    packageVersion: any;
+    packageRoot: any;
+    packageLinkPath: any;
+    source: any;
+    expo: {
+        rootViewComponents: any;
+    };
+    rnoh: RnohMetadata;
+    harmony: import("../types").HarmonyModuleMetadata;
+}>;
+export { createDescriptorFromSearchRecordAsync, };