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

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

@@ -0,0 +1,419 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkRnohAsync = linkRnohAsync;
+const node_child_process_1 = __importDefault(require("node:child_process"));
+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 options_1 = require("../../config/options");
+const values_1 = require("../../utilities/values");
+const generate_1 = require("../manifest/generate");
+const canonicalize_1 = require("../persistence/canonicalize");
+const packageMetadata_1 = require("./packageMetadata");
+const cli_1 = require("./cli");
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_OUTPUT_LIMIT = 64 * 1024;
+function appendBounded(current, chunk, limit) {
+    if (current.length >= limit)
+        return current;
+    return Buffer.concat([current, chunk.subarray(0, limit - current.length)]);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function spawnBoundedAsync(executable, argv, options = {}) {
+    return new Promise((resolve, reject) => {
+        const outputLimit = options.outputLimit === undefined ? DEFAULT_OUTPUT_LIMIT : options.outputLimit;
+        const timeoutMs = options.timeoutMs === undefined ? DEFAULT_TIMEOUT_MS : options.timeoutMs;
+        if (!Number.isInteger(outputLimit) || outputLimit <= 0
+            || !Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+            reject(new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'timeoutMs and outputLimit must be positive integers.', { stage: 'rnoh-preflight' }));
+            return;
+        }
+        let stdout = Buffer.alloc(0);
+        let stderr = Buffer.alloc(0);
+        let stdoutTruncated = false;
+        let stderrTruncated = false;
+        let timedOut = false;
+        let killTimer;
+        // eslint-disable-next-line prefer-const
+        let timeout;
+        let settled = false;
+        let child;
+        try {
+            child = node_child_process_1.default.spawn(executable, argv, {
+                cwd: options.cwd,
+                env: options.env || process.env,
+                shell: false,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch (cause) {
+            reject(cause);
+            return;
+        }
+        child.stdout.on('data', (chunk) => {
+            if (stdout.length + chunk.length > outputLimit)
+                stdoutTruncated = true;
+            stdout = appendBounded(stdout, chunk, outputLimit);
+        });
+        child.stderr.on('data', (chunk) => {
+            if (stderr.length + chunk.length > outputLimit)
+                stderrTruncated = true;
+            stderr = appendBounded(stderr, chunk, outputLimit);
+        });
+        child.on('error', (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            clearTimeout(killTimer);
+            reject(error);
+        });
+        timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            killTimer = setTimeout(() => child.kill('SIGKILL'), 1_000);
+            killTimer.unref?.();
+        }, timeoutMs);
+        timeout.unref?.();
+        child.on('close', (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            clearTimeout(killTimer);
+            resolve({
+                code,
+                signal,
+                timedOut,
+                stdout: stdout.toString('utf8'),
+                stderr: stderr.toString('utf8'),
+                stdoutTruncated,
+                stderrTruncated,
+            });
+        });
+    });
+}
+async function readGeneratedArtifactsAsync(harmony, allowedRoot) {
+    const lexicalAllowed = node_path_1.default.resolve(allowedRoot);
+    const lexicalRoot = node_path_1.default.resolve(harmony);
+    let root;
+    try {
+        if (!(0, values_1.isPathInside)(lexicalAllowed, lexicalRoot))
+            throw new TypeError('outside staging root');
+        const allowed = await node_fs_1.default.promises.realpath(lexicalAllowed);
+        root = await node_fs_1.default.promises.realpath(lexicalRoot);
+        const stat = await node_fs_1.default.promises.stat(root);
+        if (!(0, values_1.isPathInside)(allowed, root) || !stat.isDirectory())
+            throw new TypeError('unsafe staging root');
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError('GENERATED_ARTIFACT_MISSING', 'RNOH output root must resolve to a directory inside the staging project.', { cause, stage: 'rnoh-validate' });
+    }
+    const artifacts = {};
+    for (const [name, relative] of Object.entries(constants_1.RnohArtifacts)) {
+        const target = node_path_1.default.join(root, relative);
+        let stat;
+        let realTarget;
+        let artifact;
+        try {
+            if (!(0, values_1.isPathInside)(root, target))
+                throw new TypeError('outside staging root');
+            stat = await node_fs_1.default.promises.lstat(target);
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.size === 0) {
+                throw new TypeError('not a non-empty regular file');
+            }
+            realTarget = await node_fs_1.default.promises.realpath(target);
+            if (!(0, values_1.isPathInside)(root, realTarget))
+                throw new TypeError('outside staging root');
+            artifact = name === 'cppFactory'
+                ? { path: realTarget }
+                : { path: realTarget, content: await node_fs_1.default.promises.readFile(realTarget, 'utf8') };
+        }
+        catch (cause) {
+            throw new errors_1.HarmonyAutolinkingError('GENERATED_ARTIFACT_MISSING', `RNOH did not generate a non-empty regular ${relative}.`, {
+                cause,
+                stage: 'rnoh-validate',
+                details: { artifact: relative },
+            });
+        }
+        artifacts[name] = artifact;
+    }
+    return artifacts;
+}
+function buildLinkCommandArgs(linkOptions) {
+    (0, options_1.assertSafeRnohPackageList)(linkOptions.include || [], 'include', 'rnoh-preflight');
+    (0, options_1.assertSafeRnohPackageList)(linkOptions.exclude || [], 'exclude', 'rnoh-preflight');
+    if (linkOptions.include?.length && linkOptions.exclude?.length) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'include and exclude cannot both be set for RNOH link-harmony.', { stage: 'rnoh-preflight' });
+    }
+    const argv = [
+        'link-harmony',
+        '--harmony-project-path', linkOptions.harmonyProjectPath,
+        '--node-modules-path', linkOptions.nodeModulesPath,
+        '--cmake-autolink-path-relative-to-harmony', constants_1.RnohArtifacts.cmake,
+        '--cpp-rnoh-packages-factory-path-relative-to-harmony', constants_1.RnohArtifacts.cppFactory,
+        '--ets-rnoh-packages-factory-path-relative-to-harmony', constants_1.RnohArtifacts.etsFactory,
+        '--oh-package-path-relative-to-harmony', constants_1.RnohArtifacts.ohPackage,
+    ];
+    if (linkOptions.include?.length)
+        argv.push('--include-npm-packages', linkOptions.include.join(';'));
+    if (linkOptions.exclude?.length)
+        argv.push('--exclude-npm-packages', linkOptions.exclude.join(';'));
+    return argv;
+}
+function describeProcessFailure(result, roots) {
+    const reason = result.timedOut
+        ? 'timed out'
+        : result.signal
+            ? `was terminated by ${result.signal}`
+            : `exited with code ${result.code}`;
+    const stderr = (0, values_1.sanitizeOutput)(result.stderr, roots);
+    return `React Native link-harmony ${reason}${stderr ? `: ${stderr}` : '.'}`;
+}
+function patchEtsFactorySource(source, descriptors) {
+    // RNOH 0.84.1 emits this exact zero-argument factory shape. Convert only that
+    // current toolchain output so any upstream change is visible in CI.
+    const generated = 'import type { RNPackageContext, RNOHPackage } from \'@rnoh/react-native-openharmony\';';
+    const packageTypes = 'import type { RNPackage, RNPackageContext } from \'@rnoh/react-native-openharmony\';';
+    const generatedHostProvider = 'import { expoHarmonyHostProvider } from \'./generated/ExpoHarmonyHostProvider\';';
+    const coreRootImport = 'import ExpoModulesCorePackage from \'@expo-harmony/expo-modules-core\';';
+    const coreAutolinkingImport = 'import ExpoModulesCorePackage from \'@expo-harmony/expo-modules-core/Autolinking\';';
+    const replacements = [
+        [generated, `${packageTypes}\n${generatedHostProvider}`, 'RNOH package type import'],
+        [coreRootImport, coreAutolinkingImport, 'Expo Modules Core package import'],
+        ['): RNOHPackage[] {', '): RNPackage[] {', 'RNOH package factory return type'],
+        [
+            'new ExpoModulesCorePackage(ctx)',
+            'new ExpoModulesCorePackage(ctx, expoHarmonyHostProvider.expoModules, expoHarmonyHostProvider.hostState)',
+            'Expo Modules Core zero-argument registration',
+        ],
+    ];
+    const namedImports = new Map();
+    for (const descriptor of descriptors.filter(item => item.rnoh.harPaths.length > 0)) {
+        const rnohMetadata = (0, packageMetadata_1.resolveRnohMetadata)(descriptor);
+        if (rnohMetadata.etsPackageImport !== 'named')
+            continue;
+        const name = rnohMetadata.harMappings[0].ohPackageName;
+        const defaultImport = `import ${rnohMetadata.etsPackageClassName} from '${name}';`;
+        const namedImport = `import { ${rnohMetadata.etsPackageClassName} } from '${name}';`;
+        namedImports.set(defaultImport, namedImport);
+    }
+    for (const [defaultImport, namedImport] of namedImports) {
+        replacements.push([defaultImport, namedImport, 'RNOH named package import']);
+    }
+    let content = source;
+    for (const [generatedFragment, replacement, name] of replacements) {
+        const fragments = content.split(generatedFragment);
+        if (fragments.length !== 2) {
+            throw new errors_1.HarmonyAutolinkingError('GENERATED_ARTIFACT_SET_MISMATCH', `RNOH 0.84.1 generated factory did not contain exactly one expected ${name}.`, { stage: 'rnoh-patch', details: { fragment: name } });
+        }
+        content = `${fragments[0]}${replacement}${fragments[1]}`;
+    }
+    return content;
+}
+async function patchEtsFactoryAsync(artifact, descriptors) {
+    const content = patchEtsFactorySource(artifact.content, descriptors);
+    if (content !== artifact.content) {
+        await node_fs_1.default.promises.writeFile(artifact.path, content);
+        artifact.content = content;
+    }
+}
+function patchCmakeSource(source, descriptors) {
+    let content = source;
+    const guardedBlocks = new Map();
+    for (const descriptor of descriptors.filter(item => item.rnoh.harPaths.length > 0)) {
+        const metadata = (0, packageMetadata_1.resolveRnohMetadata)(descriptor);
+        const generated = `    add_subdirectory("\${OH_MODULES_DIR}/${descriptor.packageName}/src/main/cpp" ./${metadata.cmakeLibraryTargetName})`;
+        const guarded = [
+            `    if(NOT TARGET ${metadata.cmakeLibraryTargetName})`,
+            `      add_subdirectory("\${OH_MODULES_DIR}/${descriptor.packageName}/src/main/cpp" ./${metadata.cmakeLibraryTargetName})`,
+            '    endif()',
+        ].join('\n');
+        guardedBlocks.set(metadata.cmakeLibraryTargetName, guarded);
+        const fragments = content.split(generated);
+        if (fragments.length !== 2) {
+            throw new errors_1.HarmonyAutolinkingError('GENERATED_ARTIFACT_SET_MISMATCH', `RNOH 0.84.1 generated CMake did not contain exactly one add_subdirectory for ${descriptor.packageName}.`, { stage: 'rnoh-patch', packageName: descriptor.packageName });
+        }
+        content = `${fragments[0]}${guarded}${fragments[1]}`;
+    }
+    // Core consumes the dependency's public CMake target. Configure Worklets
+    // first instead of making Core compile a private copy of dependency sources.
+    const coreBlock = guardedBlocks.get('expo_harmony__expo_modules_core');
+    const workletsBlock = guardedBlocks.get('rnoh_worklets');
+    if (coreBlock && workletsBlock) {
+        const coreIndex = content.indexOf(coreBlock);
+        const workletsIndex = content.indexOf(workletsBlock);
+        if (coreIndex >= 0 && workletsIndex > coreIndex) {
+            content = content.replace(`${workletsBlock}\n`, '');
+            const updatedCoreIndex = content.indexOf(coreBlock);
+            content = `${content.slice(0, updatedCoreIndex)}${workletsBlock}\n${content.slice(updatedCoreIndex)}`;
+        }
+        // The Harmony Worklets package cannot infer the Hermes ABI selected by the
+        // application. Forward the real build setting after its public target has
+        // been configured; Core must not hard-code or override dependency sources.
+        const configuredWorkletsBlock = [
+            workletsBlock,
+            // Worklets 1.0.0 declares implementation files as PUBLIC sources. Do not
+            // make every linked consumer compile the dependency implementation again.
+            '    set_property(TARGET rnoh_worklets PROPERTY INTERFACE_SOURCES "")',
+            '    set(EXPO_RNOH_PACKAGE_JSON_PATH "${OH_MODULES_DIR}/@rnoh/react-native-openharmony/oh-package.json5")',
+            '    if(NOT EXISTS "${EXPO_RNOH_PACKAGE_JSON_PATH}")',
+            '      message(FATAL_ERROR "Unable to locate the RNOH package manifest")',
+            '    endif()',
+            '    file(READ "${EXPO_RNOH_PACKAGE_JSON_PATH}" EXPO_RNOH_PACKAGE_JSON)',
+            '    string(JSON EXPO_RNOH_VERSION GET "${EXPO_RNOH_PACKAGE_JSON}" version)',
+            '    if(NOT EXPO_RNOH_VERSION MATCHES "^0\\\\.([0-9]+)\\\\.")',
+            '      message(FATAL_ERROR "Unable to derive the React Native minor from RNOH ${EXPO_RNOH_VERSION}")',
+            '    endif()',
+            '    set(EXPO_RNOH_MINOR_VERSION "${CMAKE_MATCH_1}")',
+            '    target_compile_definitions(rnoh_worklets PUBLIC REACT_NATIVE_MINOR_VERSION=${EXPO_RNOH_MINOR_VERSION})',
+            '    if(DEFINED ENV{HERMES_V1_ENABLED} AND "$ENV{HERMES_V1_ENABLED}" STREQUAL "true")',
+            '      target_compile_definitions(rnoh_worklets PRIVATE HERMES_V1_ENABLED=1)',
+            '    endif()',
+            '    if(EXPO_RNOH_MINOR_VERSION GREATER_EQUAL 84)',
+            '      set(EXPO_WORKLETS_MODULE_SOURCE "${OH_MODULES_DIR}/@react-native-ohos/react-native-worklets/src/main/cpp/WorkletsModule.cpp")',
+            '      file(READ "${EXPO_WORKLETS_MODULE_SOURCE}" EXPO_WORKLETS_MODULE_CONTENT)',
+            '      set(EXPO_WORKLETS_OLD_FRAGMENT "std::shared_ptr<const BigStringBuffer> script = nullptr;")',
+            '      string(FIND "${EXPO_WORKLETS_MODULE_CONTENT}" "${EXPO_WORKLETS_OLD_FRAGMENT}" EXPO_WORKLETS_FRAGMENT_OFFSET)',
+            '      if(EXPO_WORKLETS_FRAGMENT_OFFSET EQUAL -1)',
+            '        message(FATAL_ERROR "Worklets Harmony wrapper no longer matches the guarded RN 0.84 compatibility patch")',
+            '      endif()',
+            '      string(REPLACE "${EXPO_WORKLETS_OLD_FRAGMENT}" "std::shared_ptr<const JSBigStringBuffer> script = nullptr;" EXPO_WORKLETS_MODULE_CONTENT "${EXPO_WORKLETS_MODULE_CONTENT}")',
+            '      set(EXPO_WORKLETS_OLD_FRAGMENT "auto jsBigString = std::make_unique<JSBigBufferString>(len);")',
+            '      string(FIND "${EXPO_WORKLETS_MODULE_CONTENT}" "${EXPO_WORKLETS_OLD_FRAGMENT}" EXPO_WORKLETS_FRAGMENT_OFFSET)',
+            '      if(EXPO_WORKLETS_FRAGMENT_OFFSET EQUAL -1)',
+            '        message(FATAL_ERROR "Worklets Harmony bundle allocation no longer matches the guarded RN 0.84 compatibility patch")',
+            '      endif()',
+            '      string(REPLACE "${EXPO_WORKLETS_OLD_FRAGMENT}" "auto jsBigString = std::make_shared<JSBigBufferString>(len);" EXPO_WORKLETS_MODULE_CONTENT "${EXPO_WORKLETS_MODULE_CONTENT}")',
+            '      set(EXPO_WORKLETS_OLD_FRAGMENT "char *buffer = jsBigString->data();")',
+            '      string(FIND "${EXPO_WORKLETS_MODULE_CONTENT}" "${EXPO_WORKLETS_OLD_FRAGMENT}" EXPO_WORKLETS_FRAGMENT_OFFSET)',
+            '      if(EXPO_WORKLETS_FRAGMENT_OFFSET EQUAL -1)',
+            '        message(FATAL_ERROR "Worklets Harmony bundle buffer access no longer matches the guarded RN 0.84 compatibility patch")',
+            '      endif()',
+            '      string(REPLACE "${EXPO_WORKLETS_OLD_FRAGMENT}" "char *buffer = jsBigString->mutableData();" EXPO_WORKLETS_MODULE_CONTENT "${EXPO_WORKLETS_MODULE_CONTENT}")',
+            '      set(EXPO_WORKLETS_OLD_FRAGMENT "script = std::make_shared<BigStringBuffer>(std::move(jsBigString));")',
+            '      string(FIND "${EXPO_WORKLETS_MODULE_CONTENT}" "${EXPO_WORKLETS_OLD_FRAGMENT}" EXPO_WORKLETS_FRAGMENT_OFFSET)',
+            '      if(EXPO_WORKLETS_FRAGMENT_OFFSET EQUAL -1)',
+            '        message(FATAL_ERROR "Worklets Harmony bundle assignment no longer matches the guarded RN 0.84 compatibility patch")',
+            '      endif()',
+            '      string(REPLACE "${EXPO_WORKLETS_OLD_FRAGMENT}" "script = std::move(jsBigString);" EXPO_WORKLETS_MODULE_CONTENT "${EXPO_WORKLETS_MODULE_CONTENT}")',
+            '      set(EXPO_WORKLETS_PATCH_DIR "${CMAKE_CURRENT_BINARY_DIR}/expo_worklets_compat")',
+            '      file(MAKE_DIRECTORY "${EXPO_WORKLETS_PATCH_DIR}")',
+            '      set(EXPO_WORKLETS_PATCHED_MODULE "${EXPO_WORKLETS_PATCH_DIR}/WorkletsModule.cpp")',
+            '      file(WRITE "${EXPO_WORKLETS_PATCHED_MODULE}" "${EXPO_WORKLETS_MODULE_CONTENT}")',
+            '      get_target_property(EXPO_WORKLETS_SOURCES rnoh_worklets SOURCES)',
+            '      set(EXPO_WORKLETS_FILTERED_SOURCES)',
+            '      foreach(EXPO_WORKLETS_SOURCE IN LISTS EXPO_WORKLETS_SOURCES)',
+            '        if(NOT EXPO_WORKLETS_SOURCE MATCHES "(^|/)WorkletsModule\\\\.cpp$")',
+            '          list(APPEND EXPO_WORKLETS_FILTERED_SOURCES "${EXPO_WORKLETS_SOURCE}")',
+            '        endif()',
+            '      endforeach()',
+            '      set_property(TARGET rnoh_worklets PROPERTY SOURCES ${EXPO_WORKLETS_FILTERED_SOURCES})',
+            '      target_sources(rnoh_worklets PRIVATE "${EXPO_WORKLETS_PATCHED_MODULE}")',
+            '    endif()',
+        ].join('\n');
+        content = content.replace(workletsBlock, configuredWorkletsBlock);
+    }
+    return content;
+}
+async function patchCmakeAsync(artifact, descriptors) {
+    const content = patchCmakeSource(artifact.content, descriptors);
+    if (content !== artifact.content) {
+        await node_fs_1.default.promises.writeFile(artifact.path, content);
+        artifact.content = content;
+    }
+}
+function patchOhpmManifest(artifact, descriptors, buildType, harmonyProjectPath) {
+    artifact.content = (0, canonicalize_1.canonicalizeOhpmManifest)(artifact.content, (0, generate_1.createManifest)(descriptors, { buildType }), {
+        errorCode: 'RNOH_LINK_FAILED',
+        harmonyProjectPath,
+        stage: 'rnoh-patch',
+    }).source;
+}
+async function linkRnohAsync(linkOptions) {
+    const executable = await (0, cli_1.resolveCliAsync)({
+        ...linkOptions,
+        nodeModulesPath: linkOptions.commandNodeModulesPath || linkOptions.nodeModulesPath,
+    });
+    const spawn = {
+        cwd: linkOptions.stageProjectRoot,
+        env: linkOptions.env ? { ...process.env, ...linkOptions.env } : process.env,
+        outputLimit: linkOptions.outputLimit,
+        timeoutMs: linkOptions.timeoutMs,
+    };
+    let result;
+    try {
+        result = await spawnBoundedAsync(executable, buildLinkCommandArgs({
+            harmonyProjectPath: linkOptions.stageHarmonyProjectPath,
+            nodeModulesPath: linkOptions.nodeModulesPath,
+            include: linkOptions.include,
+            exclude: linkOptions.exclude,
+        }), spawn);
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError('RNOH_LINK_FAILED', 'Unable to execute React Native link-harmony.', { cause, stage: 'rnoh-link' });
+    }
+    if (result.code !== 0 || result.signal || result.timedOut) {
+        throw new errors_1.HarmonyAutolinkingError('RNOH_LINK_FAILED', describeProcessFailure(result, [linkOptions.temporaryRoot, linkOptions.projectRoot]), {
+            stage: 'rnoh-link',
+            details: {
+                exitCode: result.code,
+                signal: result.signal,
+                timedOut: result.timedOut,
+                stdoutTruncated: result.stdoutTruncated,
+                stderrTruncated: result.stderrTruncated,
+            },
+        });
+    }
+    let artifacts;
+    try {
+        artifacts = await readGeneratedArtifactsAsync(linkOptions.stageHarmonyProjectPath, linkOptions.stageProjectRoot);
+    }
+    catch (error) {
+        const roots = [linkOptions.temporaryRoot, linkOptions.stageProjectRoot, linkOptions.projectRoot];
+        const details = {
+            ...(error.details || {}),
+            stdout: (0, values_1.sanitizeOutput)(result.stdout, roots),
+            stderr: (0, values_1.sanitizeOutput)(result.stderr, roots),
+            stdoutTruncated: result.stdoutTruncated,
+            stderrTruncated: result.stderrTruncated,
+        };
+        throw new errors_1.HarmonyAutolinkingError(typeof error.code === 'string' ? error.code : 'RNOH_LINK_FAILED', error.message || 'RNOH did not generate the required artifacts.', {
+            cause: error,
+            stage: error.stage || 'rnoh-validate',
+            packageName: error.packageName,
+            diagnostics: error.diagnostics,
+            details,
+        });
+    }
+    if (linkOptions.modules) {
+        try {
+            await patchCmakeAsync(artifacts.cmake, linkOptions.modules);
+            await patchEtsFactoryAsync(artifacts.etsFactory, linkOptions.modules);
+            patchOhpmManifest(artifacts.ohPackage, linkOptions.modules, linkOptions.buildType, linkOptions.harmonyProjectPath);
+            await node_fs_1.default.promises.writeFile(artifacts.ohPackage.path, artifacts.ohPackage.content);
+        }
+        catch (error) {
+            const roots = [linkOptions.temporaryRoot, linkOptions.stageProjectRoot, linkOptions.projectRoot];
+            const details = {
+                ...(error.details || {}),
+                stdout: (0, values_1.sanitizeOutput)(result.stdout, roots),
+                stderr: (0, values_1.sanitizeOutput)(result.stderr, roots),
+                stdoutTruncated: result.stdoutTruncated,
+                stderrTruncated: result.stderrTruncated,
+            };
+            throw new errors_1.HarmonyAutolinkingError(typeof error.code === 'string' ? error.code : 'RNOH_LINK_FAILED', error.message || 'Unable to patch RNOH artifacts.', {
+                cause: error,
+                stage: error.stage || 'rnoh-validate',
+                packageName: error.packageName,
+                diagnostics: error.diagnostics,
+                details,
+            });
+        }
+    }
+    return artifacts;
+}

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

@@ -0,0 +1,12 @@
+declare function defaultCmakeTargetForNpmPackage(packageName: any): string;
+declare function defaultOhPackageNameForNpmPackage(packageName: any): string;
+declare function ohPackageNameForHar(base: any, harPath: any, harCount: any): any;
+declare function resolveRnohMetadata(descriptor: any): {
+    packageName: any;
+    harMappings: any;
+    etsPackageClassName: any;
+    etsPackageImport: any;
+    cppPackageClassName: any;
+    cmakeLibraryTargetName: any;
+};
+export { defaultCmakeTargetForNpmPackage, defaultOhPackageNameForNpmPackage, ohPackageNameForHar, resolveRnohMetadata, };

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

@@ -0,0 +1,125 @@
+"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.defaultCmakeTargetForNpmPackage = defaultCmakeTargetForNpmPackage;
+exports.defaultOhPackageNameForNpmPackage = defaultOhPackageNameForNpmPackage;
+exports.ohPackageNameForHar = ohPackageNameForHar;
+exports.resolveRnohMetadata = resolveRnohMetadata;
+const path = __importStar(require("node:path"));
+const case_1 = __importDefault(require("case"));
+const errors_1 = require("../../errors");
+function packageNameParts(packageName) {
+    if (packageName.startsWith('@')) {
+        const [scopeName, name] = packageName.slice(1).split('/');
+        return { scopeName, name };
+    }
+    return { scopeName: null, name: packageName };
+}
+function defaultPackageClassName(packageName) {
+    const { scopeName, name } = packageNameParts(packageName);
+    return scopeName
+        ? `${case_1.default.pascal(scopeName)}${case_1.default.pascal(name)}Package`
+        : `${case_1.default.pascal(name)}Package`;
+}
+function defaultCmakeTargetForNpmPackage(packageName) {
+    const { scopeName, name } = packageNameParts(packageName);
+    return scopeName
+        ? `rnoh__${case_1.default.snake(scopeName)}__${case_1.default.snake(name)}`
+        : `rnoh__${case_1.default.snake(name)}`;
+}
+function defaultOhPackageNameForNpmPackage(packageName) {
+    const { scopeName, name } = packageNameParts(packageName);
+    return scopeName
+        ? `@rnoh/${case_1.default.kebab(scopeName)}--${case_1.default.kebab(name)}`
+        : `@rnoh/${case_1.default.kebab(name)}`;
+}
+function ohPackageNameForHar(base, harPath, harCount) {
+    return harCount > 1
+        ? `${base}--${path.basename(harPath, '.har')}`
+        : base;
+}
+function resolveHarPackageMappings(descriptor) {
+    const harPaths = descriptor.rnoh.harPaths || [];
+    if (harPaths.length === 0)
+        return [];
+    const configured = descriptor.rnoh.ohPackageName;
+    if (configured === undefined) {
+        const base = defaultOhPackageNameForNpmPackage(descriptor.packageName);
+        return harPaths.map(harPath => ({
+            harPath,
+            ohPackageName: ohPackageNameForHar(base, harPath, harPaths.length),
+        }));
+    }
+    if (typeof configured === 'string') {
+        return harPaths.map(harPath => ({
+            harPath,
+            ohPackageName: ohPackageNameForHar(configured, harPath, harPaths.length),
+        }));
+    }
+    const defaultName = defaultOhPackageNameForNpmPackage(descriptor.packageName);
+    return harPaths.map((harPath) => {
+        const mapping = configured.find(item => item.harName === path.basename(harPath));
+        if (!mapping)
+            return {
+                harPath,
+                ohPackageName: ohPackageNameForHar(defaultName, harPath, harPaths.length),
+            };
+        return {
+            harPath,
+            ohPackageName: mapping.packageName,
+            ...(mapping.version ? { version: mapping.version } : {}),
+        };
+    });
+}
+function resolveRnohMetadata(descriptor) {
+    const pkg = defaultPackageClassName(descriptor.packageName);
+    if ((descriptor.rnoh.etsPackageClassName === undefined
+        || descriptor.rnoh.cppPackageClassName === undefined)
+        && !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(pkg)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'The npm package name cannot produce a valid default RNOH package class; configure the package class names explicitly.', { packageName: descriptor.packageName, stage: 'metadata' });
+    }
+    return {
+        packageName: descriptor.packageName,
+        harMappings: resolveHarPackageMappings(descriptor),
+        etsPackageClassName: descriptor.rnoh.etsPackageClassName || pkg,
+        etsPackageImport: descriptor.rnoh.etsPackageImport || 'default',
+        cppPackageClassName: descriptor.rnoh.cppPackageClassName || pkg,
+        cmakeLibraryTargetName: descriptor.rnoh.cmakeLibraryTargetName
+            || defaultCmakeTargetForNpmPackage(descriptor.packageName),
+    };
+}

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

@@ -0,0 +1,15 @@
+declare function readPreviousAutolinkingStateAsync(projectRoot: any): Promise<{
+    artifacts: string[];
+    managedOhpmPackageNames: string[];
+    warning: any;
+} | {
+    artifacts: any[];
+    managedOhpmPackageNames: any[];
+    warning: {
+        severity: string;
+        code: string;
+        message: any;
+        stage: string;
+    };
+}>;
+export { readPreviousAutolinkingStateAsync, };

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

@@ -0,0 +1,96 @@
+"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.readPreviousAutolinkingStateAsync = readPreviousAutolinkingStateAsync;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const constants_1 = require("../../config/constants");
+const manifest_1 = require("../manifest");
+const values_1 = require("../../utilities/values");
+const ManagedSuffixes = [
+    ...Object.values(constants_1.RnohArtifacts),
+    ...Object.values(constants_1.ExpoArtifacts),
+];
+function isManagedArtifactPath(relativePath) {
+    if (relativePath === constants_1.ManifestArtifact)
+        return true;
+    return ManagedSuffixes.some(suffix => relativePath === suffix || relativePath.endsWith(`/${suffix}`));
+}
+function normalizeManagedArtifactPath(value) {
+    if (typeof value !== 'string' || !value || value.includes('\\') || path.posix.isAbsolute(value)) {
+        return null;
+    }
+    const normalized = path.posix.normalize(value);
+    if (normalized !== value || normalized === '..' || normalized.startsWith('../'))
+        return null;
+    return isManagedArtifactPath(normalized) ? normalized : null;
+}
+function staleManifestWarning(message) {
+    return {
+        severity: 'warning',
+        code: 'ERR_EXPO_HARMONY_STALE_MANIFEST_IGNORED',
+        message,
+        stage: 'publish',
+    };
+}
+async function readPreviousAutolinkingStateAsync(projectRoot) {
+    const manifestPath = path.join(projectRoot, constants_1.ManifestArtifact);
+    if (!(await (0, values_1.pathExistsAsync)(manifestPath))) {
+        return { artifacts: [], managedOhpmPackageNames: [], warning: null };
+    }
+    try {
+        const stat = await fs.promises.lstat(manifestPath);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new TypeError('manifest is not a regular file');
+        const manifest = (0, manifest_1.validateManifest)(JSON.parse(await fs.promises.readFile(manifestPath, 'utf8')), { file: manifestPath });
+        const normalized = manifest.managedArtifacts.map(normalizeManagedArtifactPath);
+        if (normalized.some(value => value == null))
+            throw new TypeError('manifest contains an unsafe path');
+        const artifacts = normalized.filter((value) => value !== null);
+        return {
+            artifacts: [...new Set(artifacts)].map(relative => path.join(projectRoot, ...relative.split('/'))),
+            managedOhpmPackageNames: Object.keys((0, manifest_1.ohpmDependenciesFromManifest)(manifest))
+                .sort((left, right) => left.localeCompare(right, 'en')),
+            warning: null,
+        };
+    }
+    catch (_cause) {
+        return {
+            artifacts: [],
+            managedOhpmPackageNames: [],
+            warning: staleManifestWarning('The previous Harmony autolinking manifest is invalid; stale artifact cleanup was skipped.'),
+        };
+    }
+}