@expo-harmony/prebuild-config 55.0.0-harmony.1 → 55.0.0-harmony.2

package/build/api/signing.d.ts

@@ -0,0 +1 @@
+export { validateHarmonySigningConfigFile, type HarmonySigningConfig, } from '../signing';

package/build/api/signing.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHarmonySigningConfigFile = void 0;
+var signing_1 = require("../signing");
+Object.defineProperty(exports, "validateHarmonySigningConfigFile", { enumerable: true, get: function () { return signing_1.validateHarmonySigningConfigFile; } });

package/build/buildDescriptor.d.ts

@@ -0,0 +1,53 @@
+import { type NormalizedHarmonyConfig } from '@expo-harmony/config-plugins';
+declare const BuildDescriptorSchemaVersion = 2;
+declare const BuildModes: readonly ["debug", "release"];
+declare const HarmonyPlatformDirectory = "harmony";
+declare const HarmonyTemplateMarker = ".expo-harmony-template";
+type HarmonyBuildMode = typeof BuildModes[number];
+interface HarmonyBuildVariantDescriptor {
+    expectedHap: string;
+    hvigorArgs: string[];
+}
+interface HarmonyBuildDescriptor {
+    export: {
+        bundle: string;
+        manifest: string;
+        metadataRoot: string;
+        rawfileRoot: string;
+        sourceMap: string;
+    };
+    harmonyRoot: string;
+    identity: {
+        abilityName: string;
+        bundleName: string;
+        moduleName: string;
+        productName: string;
+        targetName: string;
+    };
+    moduleRoot: string;
+    nativeCache: {
+        invalidationRoots: string[];
+        stateFile: string;
+    };
+    nativeInputs: {
+        lockfile: string;
+        manifest: string;
+    };
+    projectFiles: {
+        hvigorConfig: string;
+        moduleHvigor: string;
+        moduleJson: string;
+        nativeInputsStamp: string;
+        projectBuildProfile: string;
+        rootHvigor: string;
+        templateMarker: string;
+    };
+    schemaVersion: typeof BuildDescriptorSchemaVersion;
+    variants: Record<HarmonyBuildMode, HarmonyBuildVariantDescriptor>;
+}
+declare function validateHarmonyBuildDescriptor(value: unknown): HarmonyBuildDescriptor;
+declare function createHarmonyBuildDescriptor(config: NormalizedHarmonyConfig, signing: string | null): HarmonyBuildDescriptor;
+declare function harmonyModuleSourcePath(build: HarmonyBuildDescriptor): string;
+declare function resolveHarmonyBuildPath(root: string, file: string): string;
+export { BuildDescriptorSchemaVersion, BuildModes, HarmonyPlatformDirectory, HarmonyTemplateMarker, createHarmonyBuildDescriptor, harmonyModuleSourcePath, resolveHarmonyBuildPath, validateHarmonyBuildDescriptor, };
+export type { HarmonyBuildDescriptor, HarmonyBuildMode, HarmonyBuildVariantDescriptor, };

package/build/buildDescriptor.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyTemplateMarker = exports.HarmonyPlatformDirectory = exports.BuildModes = exports.BuildDescriptorSchemaVersion = void 0;
+exports.createHarmonyBuildDescriptor = createHarmonyBuildDescriptor;
+exports.harmonyModuleSourcePath = harmonyModuleSourcePath;
+exports.resolveHarmonyBuildPath = resolveHarmonyBuildPath;
+exports.validateHarmonyBuildDescriptor = validateHarmonyBuildDescriptor;
+const node_path_1 = __importDefault(require("node:path"));
+const config_plugins_1 = require("@expo-harmony/config-plugins");
+const BuildDescriptorSchemaVersion = 2;
+exports.BuildDescriptorSchemaVersion = BuildDescriptorSchemaVersion;
+const BuildModes = Object.freeze(['debug', 'release']);
+exports.BuildModes = BuildModes;
+const HarmonyPlatformDirectory = 'harmony';
+exports.HarmonyPlatformDirectory = HarmonyPlatformDirectory;
+const HarmonyTemplateMarker = '.expo-harmony-template';
+exports.HarmonyTemplateMarker = HarmonyTemplateMarker;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isSafeRelativePath(value) {
+    if (!isNonEmptyString(value)
+        || value.includes('\\')
+        || node_path_1.default.posix.isAbsolute(value)
+        || node_path_1.default.win32.isAbsolute(value)
+        || node_path_1.default.posix.normalize(value) !== value) {
+        return false;
+    }
+    const segments = value.split('/');
+    return segments.every(segment => segment && segment !== '.' && segment !== '..');
+}
+function isStrictDescendant(root, target) {
+    const relative = node_path_1.default.posix.relative(root, target);
+    return Boolean(relative)
+        && relative !== '..'
+        && !relative.startsWith('../')
+        && !node_path_1.default.posix.isAbsolute(relative);
+}
+function validateVariant(value) {
+    if (!isRecord(value)
+        || !isSafeRelativePath(value.expectedHap)
+        || !Array.isArray(value.hvigorArgs)
+        || value.hvigorArgs.length === 0
+        || value.hvigorArgs.some(argument => !isNonEmptyString(argument) || /\0|[\r\n]/u.test(argument))) {
+        throw new TypeError('Harmony build descriptor contains an invalid build variant.');
+    }
+    return value;
+}
+function validateHarmonyBuildDescriptor(value) {
+    if (!isRecord(value) || value.schemaVersion !== BuildDescriptorSchemaVersion) {
+        throw new TypeError(`Unsupported Harmony build descriptor schema: ${isRecord(value) ? value.schemaVersion : 'invalid'}.`);
+    }
+    if (value.harmonyRoot !== HarmonyPlatformDirectory
+        || !isSafeRelativePath(value.moduleRoot)
+        || !isStrictDescendant(value.harmonyRoot, value.moduleRoot)) {
+        throw new TypeError('Harmony build descriptor contains invalid project roots.');
+    }
+    const harmonyRoot = value.harmonyRoot;
+    const moduleRoot = value.moduleRoot;
+    const identity = value.identity;
+    if (!isRecord(identity)
+        || ['abilityName', 'bundleName', 'moduleName', 'productName', 'targetName']
+            .some(field => !isNonEmptyString(identity[field]))) {
+        throw new TypeError('Harmony build descriptor contains an invalid identity.');
+    }
+    const inputs = value.nativeInputs;
+    if (!isRecord(inputs)
+        || !isSafeRelativePath(inputs.manifest)
+        || !isSafeRelativePath(inputs.lockfile)
+        || !isStrictDescendant(harmonyRoot, inputs.manifest)
+        || !isStrictDescendant(harmonyRoot, inputs.lockfile)) {
+        throw new TypeError('Harmony build descriptor contains invalid native input paths.');
+    }
+    const cache = value.nativeCache;
+    if (!isRecord(cache)
+        || !isSafeRelativePath(cache.stateFile)
+        || !isStrictDescendant(moduleRoot, cache.stateFile)
+        || !Array.isArray(cache.invalidationRoots)
+        || cache.invalidationRoots.length === 0
+        || cache.invalidationRoots.some(item => (!isSafeRelativePath(item) || !isStrictDescendant(moduleRoot, item)))) {
+        throw new TypeError('Harmony build descriptor contains invalid native cache paths.');
+    }
+    const files = value.projectFiles;
+    const roots = [
+        'hvigorConfig',
+        'nativeInputsStamp',
+        'projectBuildProfile',
+        'rootHvigor',
+        'templateMarker',
+    ];
+    const modules = ['moduleHvigor', 'moduleJson'];
+    if (!isRecord(files)
+        || [...roots, ...modules].some(field => !isSafeRelativePath(files[field]))
+        || roots.some(field => !isStrictDescendant(harmonyRoot, files[field]))
+        || modules.some(field => !isStrictDescendant(moduleRoot, files[field]))) {
+        throw new TypeError('Harmony build descriptor contains invalid project file paths.');
+    }
+    const output = value.export;
+    if (!isRecord(output)) {
+        throw new TypeError('Harmony build descriptor contains invalid export paths.');
+    }
+    const invalid = ['bundle', 'manifest', 'metadataRoot', 'rawfileRoot', 'sourceMap']
+        .some(field => !isSafeRelativePath(output[field]));
+    if (invalid
+        || !isStrictDescendant(moduleRoot, output.rawfileRoot)
+        || !isStrictDescendant(output.rawfileRoot, output.bundle)
+        || !isStrictDescendant(output.metadataRoot, output.sourceMap)) {
+        throw new TypeError('Harmony build descriptor contains invalid export paths.');
+    }
+    if (!isRecord(value.variants)
+        || Object.keys(value.variants).length !== BuildModes.length
+        || BuildModes.some(mode => !Object.hasOwn(value.variants, mode))) {
+        throw new TypeError('Harmony build descriptor must define debug and release variants.');
+    }
+    for (const mode of BuildModes) {
+        const variant = validateVariant(value.variants[mode]);
+        if (!isStrictDescendant(moduleRoot, variant.expectedHap)) {
+            throw new TypeError(`Harmony ${mode} HAP output must be inside the module root.`);
+        }
+    }
+    return value;
+}
+function createHarmonyBuildDescriptor(config, signing) {
+    const paths = config_plugins_1.HarmonyPaths.HARMONY_PATHS;
+    const harmony = HarmonyPlatformDirectory;
+    const module = `${harmony}/${node_path_1.default.posix.dirname(paths.entryBuildProfile)}`;
+    const target = 'default';
+    const rawfile = `${module}/src/main/resources/rawfile`;
+    const suffix = signing ? 'signed' : 'unsigned';
+    const variants = Object.fromEntries(BuildModes.map(mode => [mode, {
+            expectedHap: `${module}/build/${target}/outputs/${target}/${config.moduleName}-${target}-${suffix}.hap`,
+            hvigorArgs: [
+                '--mode', 'module',
+                '-p', `module=${config.moduleName}@${target}`,
+                '-p', `product=${config.productName}`,
+                '-p', `buildMode=${mode}`,
+                '--no-daemon',
+                'assembleHap',
+            ],
+        }]));
+    return validateHarmonyBuildDescriptor({
+        export: {
+            bundle: `${rawfile}/hermes_bundle.hbc`,
+            manifest: '.expo/harmony/export-manifest.json',
+            metadataRoot: '.expo/harmony/export',
+            rawfileRoot: rawfile,
+            sourceMap: '.expo/harmony/export/hermes_bundle.hbc.map',
+        },
+        harmonyRoot: harmony,
+        identity: {
+            abilityName: config.abilityName,
+            bundleName: config.bundleName,
+            moduleName: config.moduleName,
+            productName: config.productName,
+            targetName: target,
+        },
+        moduleRoot: module,
+        nativeCache: {
+            invalidationRoots: [`${module}/.cxx`, `${module}/build`],
+            stateFile: `${module}/.cxx/.expo-harmony-native-dependencies.json`,
+        },
+        nativeInputs: {
+            lockfile: `${harmony}/oh-package-lock.json5`,
+            manifest: `${harmony}/${paths.rootOhPackage}`,
+        },
+        projectFiles: {
+            hvigorConfig: `${harmony}/${paths.hvigorConfig}`,
+            moduleHvigor: `${harmony}/${paths.entryHvigor}`,
+            moduleJson: `${harmony}/${paths.moduleJson}`,
+            nativeInputsStamp: `${harmony}/${paths.nativeInputsStamp}`,
+            projectBuildProfile: `${harmony}/${paths.projectBuildProfile}`,
+            rootHvigor: `${harmony}/${paths.rootHvigor}`,
+            templateMarker: `${harmony}/${HarmonyTemplateMarker}`,
+        },
+        schemaVersion: BuildDescriptorSchemaVersion,
+        variants,
+    });
+}
+function harmonyModuleSourcePath(build) {
+    return `./${node_path_1.default.posix.relative(build.harmonyRoot, build.moduleRoot)}`;
+}
+function resolveHarmonyBuildPath(root, file) {
+    return node_path_1.default.join(root, ...file.split('/'));
+}

package/build/check.d.ts

@@ -0,0 +1,16 @@
+import { type CngManifest } from './manifest';
+interface Change {
+    path: string;
+    type: 'added' | 'changed' | 'deleted';
+}
+interface Result {
+    changes: Change[];
+    clean: boolean;
+    expected: CngManifest;
+}
+declare function readManifestIfPresentAsync(project: string): Promise<CngManifest | null>;
+declare function readManifestAsync(project: string): Promise<CngManifest>;
+declare function stageAsync(project: string, expected: string, temp: string): Promise<void>;
+declare function compareAsync(project: string, generated: string): Promise<Result>;
+export { compareAsync, readManifestAsync, readManifestIfPresentAsync, stageAsync, };
+export type { Change, Result, };

package/build/check.js

@@ -0,0 +1,254 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareAsync = compareAsync;
+exports.readManifestAsync = readManifestAsync;
+exports.readManifestIfPresentAsync = readManifestIfPresentAsync;
+exports.stageAsync = stageAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const config_1 = require("@expo/config");
+const config_plugins_1 = require("@expo-harmony/config-plugins");
+const expo_modules_autolinking_1 = require("@expo-harmony/expo-modules-autolinking");
+const json5_1 = __importDefault(require("json5"));
+const errors_1 = require("./errors");
+const buildDescriptor_1 = require("./buildDescriptor");
+const manifest_1 = require("./manifest");
+const signing_1 = require("./signing");
+function isInside(root, target) {
+    const relative = node_path_1.default.relative(root, target);
+    return relative === ''
+        || (!relative.startsWith(`..${node_path_1.default.sep}`) && relative !== '..' && !node_path_1.default.isAbsolute(relative));
+}
+function mirrorPath(temp, source) {
+    const absolute = node_path_1.default.resolve(source);
+    const parsed = node_path_1.default.parse(absolute);
+    const volume = parsed.root.replace(/[^A-Za-z0-9]+/gu, '') || 'root';
+    const segments = absolute.slice(parsed.root.length).split(node_path_1.default.sep).filter(Boolean);
+    return node_path_1.default.join(temp, 'filesystem', volume, ...segments);
+}
+async function stageAutolinkingAsync(project, target) {
+    const source = node_path_1.default.join(project, '.expo/harmony/autolinking.json');
+    let stat;
+    try {
+        stat = await node_fs_1.default.promises.lstat(source);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw new errors_1.HarmonyPrebuildError(error.code || 'ERR_HARMONY_MANIFEST_DRIFT', error.message || `Cannot inspect the previous autolinking manifest: ${source}`, { cause: error, operation: error.operation || 'check' });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink())
+        return;
+    const content = await node_fs_1.default.promises.readFile(source, 'utf8');
+    const file = node_path_1.default.join(target, '.expo/harmony/autolinking.json');
+    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(file), { recursive: true });
+    await node_fs_1.default.promises.writeFile(file, content);
+}
+async function matchesIdentity(project, cng) {
+    const identity = cng.managedIdentity;
+    let profile;
+    let module;
+    try {
+        const [profileSource, moduleSource] = await Promise.all([
+            node_fs_1.default.promises.readFile((0, buildDescriptor_1.resolveHarmonyBuildPath)(project, cng.build.projectFiles.projectBuildProfile), 'utf8'),
+            node_fs_1.default.promises.readFile((0, buildDescriptor_1.resolveHarmonyBuildPath)(project, cng.build.projectFiles.moduleJson), 'utf8'),
+        ]);
+        profile = json5_1.default.parse(profileSource);
+        module = json5_1.default.parse(moduleSource);
+    }
+    catch {
+        return false;
+    }
+    const moduleProfile = Array.isArray(profile?.modules)
+        ? profile.modules.find(item => item?.name === identity.moduleName)
+        : null;
+    const target = Array.isArray(moduleProfile?.targets)
+        ? moduleProfile.targets.find(item => item?.name === identity.targetName)
+        : null;
+    const products = Array.isArray(profile?.app?.products) ? profile.app.products : [];
+    const abilities = Array.isArray(module?.module?.abilities) ? module.module.abilities : [];
+    return module?.module?.name === identity.moduleName
+        && module?.module?.mainElement === identity.abilityName
+        && abilities.some(item => item?.name === identity.abilityName)
+        && products.some(item => item?.name === identity.productName)
+        && Array.isArray(target?.applyToProducts)
+        && target.applyToProducts.includes(identity.productName);
+}
+async function readManifestIfPresentAsync(project) {
+    const file = (0, buildDescriptor_1.resolveHarmonyBuildPath)(project, manifest_1.CngManifestPath);
+    let source;
+    try {
+        source = await node_fs_1.default.promises.readFile(file, 'utf8');
+    }
+    catch (cause) {
+        if (cause.code === 'ENOENT')
+            return null;
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_MANIFEST_DRIFT', `Cannot read CNG manifest: ${file}`, { cause, file, operation: 'check' });
+    }
+    try {
+        return (0, manifest_1.validateCngManifest)(JSON.parse(source), { file });
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_MANIFEST_DRIFT', `Cannot read CNG manifest: ${file}`, { cause, file, operation: 'check' });
+    }
+}
+async function readManifestAsync(project) {
+    const manifest = await readManifestIfPresentAsync(project);
+    if (!manifest) {
+        const file = (0, buildDescriptor_1.resolveHarmonyBuildPath)(project, manifest_1.CngManifestPath);
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_MANIFEST_DRIFT', `Cannot read CNG manifest: ${file}`, { file, operation: 'check' });
+    }
+    return manifest;
+}
+async function stageManifestAsync(project, target) {
+    const source = (0, buildDescriptor_1.resolveHarmonyBuildPath)(project, manifest_1.CngManifestPath);
+    let stat;
+    try {
+        stat = await node_fs_1.default.promises.lstat(source);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw new errors_1.HarmonyPrebuildError(error.code || 'ERR_HARMONY_MANIFEST_DRIFT', error.message || `Cannot inspect the previous CNG manifest: ${source}`, { cause: error, operation: error.operation || 'check' });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink())
+        return;
+    let cng;
+    try {
+        cng = (0, manifest_1.validateCngManifest)(JSON.parse(await node_fs_1.default.promises.readFile(source, 'utf8')), {
+            file: source,
+        });
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_MANIFEST_DRIFT', `Cannot stage the CNG manifest for isolated --check: ${source}`, { cause, file: source, operation: 'check' });
+    }
+    const config = (0, config_1.getConfig)(project, {
+        isModdedConfig: true,
+        skipSDKVersionRequirement: true,
+    }).exp;
+    const harmony = (0, config_plugins_1.normalizeHarmonyConfig)(config);
+    const hash = (0, manifest_1.hashSha256)((0, config_plugins_1.stableHarmonyJson)(harmony));
+    let identity = cng.managedIdentity;
+    let build = cng.build;
+    let signing = cng.signingConfigName;
+    if (hash === cng.inputs.configHash) {
+        // Reconstruct mutable re-entry state from authoritative inputs so a corrupt
+        // manifest cannot make isolated prebuild overwrite user-owned identities.
+        signing = harmony.signingConfigFile
+            ? (await (0, signing_1.validateHarmonySigningConfigFile)(project, harmony.signingConfigFile)).name
+            : null;
+        build = (0, buildDescriptor_1.createHarmonyBuildDescriptor)(harmony, signing);
+        identity = {
+            abilityName: build.identity.abilityName,
+            moduleName: build.identity.moduleName,
+            productName: build.identity.productName,
+            targetName: build.identity.targetName,
+        };
+    }
+    else if (!await matchesIdentity(project, cng)) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_MANIFEST_DRIFT', 'The CNG manifest identity does not match the generated Harmony project. Run prebuild to repair it before changing Harmony identity fields.', { operation: 'check' });
+    }
+    const file = (0, buildDescriptor_1.resolveHarmonyBuildPath)(target, manifest_1.CngManifestPath);
+    await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(file), { recursive: true });
+    await node_fs_1.default.promises.writeFile(file, (0, config_plugins_1.stableHarmonyJson)({
+        ...cng,
+        build,
+        managedIdentity: identity,
+        signingConfigName: signing,
+    }));
+}
+async function stageSigningAsync(project, temp) {
+    const config = (0, config_1.getConfig)(project, {
+        isModdedConfig: true,
+        skipSDKVersionRequirement: true,
+    }).exp;
+    const reference = config.harmony?.signingConfigFile;
+    if (!reference)
+        return;
+    const signing = await (0, signing_1.validateHarmonySigningConfigFile)(project, reference);
+    const inputs = [signing.file, ...Object.values(signing.materialFiles)];
+    for (const source of inputs) {
+        if (isInside(project, source))
+            continue;
+        const target = mirrorPath(temp, source);
+        if (!isInside(temp, target)) {
+            throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_SIGNING_INVALID', `External Harmony signing input escapes the isolated --check workspace: ${source}`, { operation: 'check-signing' });
+        }
+        await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(target), { recursive: true });
+        await node_fs_1.default.promises.copyFile(source, target);
+    }
+}
+async function stageAsync(project, expected, temp) {
+    await stageManifestAsync(project, expected);
+    await stageAutolinkingAsync(project, expected);
+    await stageSigningAsync(project, temp);
+}
+async function canonicalizeAutolinkingAsync(expected, project, cng) {
+    const manifestFile = node_path_1.default.join(expected, '.expo/harmony/autolinking.json');
+    const ohpmPath = cng.build.nativeInputs.manifest;
+    const ohpmFile = (0, buildDescriptor_1.resolveHarmonyBuildPath)(expected, ohpmPath);
+    try {
+        const [manifest, ohpm, generatedRoot, projectRoot] = await Promise.all([
+            node_fs_1.default.promises.readFile(manifestFile, 'utf8'),
+            node_fs_1.default.promises.readFile(ohpmFile, 'utf8'),
+            node_fs_1.default.promises.realpath(expected),
+            node_fs_1.default.promises.realpath(project),
+        ]);
+        const result = (0, expo_modules_autolinking_1.canonicalizeAutolinkingArtifacts)({
+            manifestSource: manifest,
+            ohPackageSource: ohpm,
+            generatedProjectRoot: generatedRoot,
+            canonicalProjectRoot: projectRoot,
+            harmonyProjectPath: (0, buildDescriptor_1.resolveHarmonyBuildPath)(projectRoot, cng.build.harmonyRoot),
+        });
+        const manifestHash = (0, manifest_1.hashSha256)(result.manifestSource);
+        const ohpmHash = (0, manifest_1.hashSha256)(result.ohPackageSource);
+        cng.inputs.autolinkingHash = manifestHash;
+        const manifestEntry = cng.managedFiles.find(item => item.path === '.expo/harmony/autolinking.json');
+        const ohpmEntry = cng.managedFiles.find(item => item.path === ohpmPath);
+        if (manifestEntry)
+            manifestEntry.sha256 = manifestHash;
+        if (ohpmEntry)
+            ohpmEntry.sha256 = ohpmHash;
+    }
+    catch (error) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_MANIFEST_DRIFT', 'Cannot canonicalize the isolated autolinking artifacts.', { cause: error, file: manifestFile, operation: 'check' });
+    }
+}
+async function compareAsync(project, generated) {
+    const expected = await readManifestAsync(generated);
+    await canonicalizeAutolinkingAsync(generated, project, expected);
+    const actual = await readManifestAsync(project);
+    const expectedFiles = new Map(expected.managedFiles.map(item => [item.path, item]));
+    const actualFiles = new Map(actual.managedFiles.map(item => [item.path, item]));
+    const changes = [];
+    for (const [relative, descriptor] of expectedFiles) {
+        const file = node_path_1.default.join(project, ...relative.split('/'));
+        let hash = null;
+        try {
+            hash = (0, manifest_1.hashSha256)(Uint8Array.from(await node_fs_1.default.promises.readFile(file)));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw new errors_1.HarmonyPrebuildError(error.code || 'ERR_HARMONY_MANIFEST_DRIFT', error.message || `Cannot read a managed Harmony file: ${file}`, { cause: error, file, operation: error.operation || 'check' });
+            }
+        }
+        if (hash === null)
+            changes.push({ path: relative, type: 'added' });
+        else if (hash !== descriptor.sha256)
+            changes.push({ path: relative, type: 'changed' });
+    }
+    for (const relative of actualFiles.keys()) {
+        if (!expectedFiles.has(relative))
+            changes.push({ path: relative, type: 'deleted' });
+    }
+    if (!(0, node_util_1.isDeepStrictEqual)(expected, actual)) {
+        changes.push({ path: manifest_1.CngManifestPath, type: 'changed' });
+    }
+    changes.sort((left, right) => (left.path.localeCompare(right.path, 'en') || left.type.localeCompare(right.type, 'en')));
+    return { changes, clean: changes.length === 0, expected };
+}

package/build/dependencies.d.ts

@@ -0,0 +1,6 @@
+declare function resolvePackageVersion(root: any, name: any): string;
+declare function resolveTemplateFile(relative: any): string;
+declare function readTemplateSource(relative: any): Promise<string>;
+declare function resolveRnohHvigorPlugin(root: any): string;
+declare function toRelativeDependency(directory: any, file: any): string;
+export { readTemplateSource, resolvePackageVersion, resolveRnohHvigorPlugin, resolveTemplateFile, toRelativeDependency, };

package/build/dependencies.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTemplateSource = readTemplateSource;
+exports.resolvePackageVersion = resolvePackageVersion;
+exports.resolveRnohHvigorPlugin = resolveRnohHvigorPlugin;
+exports.resolveTemplateFile = resolveTemplateFile;
+exports.toRelativeDependency = toRelativeDependency;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const template_1 = require("./template");
+const resolveModule = (0, node_module_1.createRequire)(__filename).resolve;
+function resolvePackageFile(root, name, relative) {
+    const logical = node_path_1.default.join(root, 'node_modules', ...name.split('/'), relative);
+    if (node_fs_1.default.existsSync(logical))
+        return logical;
+    let json;
+    try {
+        json = resolveModule(`${name}/package.json`, { paths: [root] });
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_DEPENDENCY_MISSING', `Unable to resolve ${name} from the project.`, { cause, operation: 'resolve-dependency' });
+    }
+    const resolved = node_path_1.default.join(node_path_1.default.dirname(json), relative);
+    if (!node_fs_1.default.existsSync(resolved)) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_DEPENDENCY_MISSING', `${name} is missing ${relative}.`, { file: resolved, operation: 'resolve-dependency' });
+    }
+    return resolved;
+}
+function resolvePackageVersion(root, name) {
+    const json = resolvePackageFile(root, name, 'package.json');
+    let version;
+    try {
+        version = JSON.parse(node_fs_1.default.readFileSync(json, 'utf8')).version;
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_DEPENDENCY_MISSING', `Cannot read ${name} version.`, { cause, file: json, operation: 'resolve-dependency' });
+    }
+    if (typeof version !== 'string' || !version) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_DEPENDENCY_MISSING', `${name} has no package version.`, { file: json, operation: 'resolve-dependency' });
+    }
+    return version;
+}
+function resolveTemplateFile(relative) {
+    const resolved = node_path_1.default.join((0, template_1.resolve)().root, relative);
+    if (!node_fs_1.default.existsSync(resolved)) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_DEPENDENCY_MISSING', `@expo-harmony/template is missing ${relative}.`, { file: resolved, operation: 'resolve-dependency' });
+    }
+    return resolved;
+}
+async function readTemplateSource(relative) {
+    return node_fs_1.default.promises.readFile(resolveTemplateFile(`harmony/${relative}`), 'utf8');
+}
+function resolveRnohHvigorPlugin(root) {
+    const json = resolvePackageFile(root, '@react-native-oh/react-native-harmony-cli', 'package.json');
+    const harmony = node_path_1.default.join(node_path_1.default.dirname(json), 'harmony');
+    let candidates;
+    try {
+        candidates = node_fs_1.default.readdirSync(harmony)
+            .filter(name => /^rnoh-hvigor-plugin-.+\.tgz$/u.test(name))
+            .sort();
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_DEPENDENCY_MISSING', '@react-native-oh/react-native-harmony-cli has no Harmony Hvigor plugin directory.', { cause, file: harmony, operation: 'resolve-dependency' });
+    }
+    if (candidates.length !== 1) {
+        throw new errors_1.HarmonyPrebuildError('ERR_HARMONY_DEPENDENCY_MISSING', '@react-native-oh/react-native-harmony-cli must contain exactly one RNOH Hvigor plugin archive.', { file: harmony, operation: 'resolve-dependency' });
+    }
+    return node_path_1.default.join(harmony, candidates[0]);
+}
+function toRelativeDependency(directory, file) {
+    return node_path_1.default.relative(directory, file).split(node_path_1.default.sep).join('/');
+}

package/build/errors.d.ts

@@ -0,0 +1,13 @@
+interface HarmonyPrebuildErrorOptions {
+    cause?: unknown;
+    file?: string;
+    operation?: string;
+}
+declare class HarmonyPrebuildError extends Error {
+    readonly code: string;
+    readonly file?: string;
+    readonly operation: string;
+    constructor(code: string, message: string, options?: HarmonyPrebuildErrorOptions);
+}
+export { HarmonyPrebuildError };
+export type { HarmonyPrebuildErrorOptions };

package/build/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyPrebuildError = void 0;
+class HarmonyPrebuildError extends Error {
+    code;
+    file;
+    operation;
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'HarmonyPrebuildError';
+        this.code = code;
+        this.operation = options.operation || 'prebuild';
+        if (options.file)
+            this.file = options.file;
+    }
+}
+exports.HarmonyPrebuildError = HarmonyPrebuildError;

package/build/generatedFiles.d.ts

@@ -0,0 +1,2 @@
+declare function ensureGitignoreEntryAsync(file: string, entry: string): Promise<void>;
+export { ensureGitignoreEntryAsync, };