@expo-harmony/expo-modules-autolinking 55.0.25-harmony.5 → 55.0.27-harmony.2

package/build/index.d.ts

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

package/build/index.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ohpmDependenciesFromManifest = exports.createNativeModuleContracts = exports.verifyModulesAsync = exports.searchModulesAsync = exports.resolveModulesAsync = exports.normalizeHarmonyModuleMetadata = exports.linkModulesAsync = exports.canonicalizeAutolinkingArtifacts = void 0;
+exports.ohpmDependenciesFromManifest = exports.createNativeModuleContracts = exports.verifyModulesAsync = exports.searchModulesAsync = exports.resolveModulesAsync = exports.normalizeHarmonyModuleMetadata = exports.prepareModulesAsync = exports.linkPreparedModulesAsync = exports.linkModulesAsync = exports.canonicalizeAutolinkingArtifacts = void 0;
 const link_1 = require("./src/autolinking/link");
 Object.defineProperty(exports, "linkModulesAsync", { enumerable: true, get: function () { return link_1.linkModulesAsync; } });
+Object.defineProperty(exports, "linkPreparedModulesAsync", { enumerable: true, get: function () { return link_1.linkPreparedModulesAsync; } });
+const prepare_1 = require("./src/autolinking/prepare");
+Object.defineProperty(exports, "prepareModulesAsync", { enumerable: true, get: function () { return prepare_1.prepareModulesAsync; } });
 const canonicalize_1 = require("./src/harmony/persistence/canonicalize");
 Object.defineProperty(exports, "canonicalizeAutolinkingArtifacts", { enumerable: true, get: function () { return canonicalize_1.canonicalizeAutolinkingArtifacts; } });
 const resolve_1 = require("./src/autolinking/resolve");

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

@@ -1,3 +1,5 @@
 import type { LinkOptions, LinkResult } from '../types';
-declare function linkModulesAsync(rawOptions: LinkOptions): Promise<LinkResult>;
-export { linkModulesAsync };
+import { prepareModulesAsync } from './prepare';
+declare function linkPreparedModulesAsync(raw: LinkOptions, prepared: Awaited<ReturnType<typeof prepareModulesAsync>>): Promise<LinkResult>;
+declare function linkModulesAsync(raw: LinkOptions): Promise<LinkResult>;
+export { linkModulesAsync, linkPreparedModulesAsync };

package/build/src/autolinking/link.js

@@ -4,20 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.linkModulesAsync = linkModulesAsync;
+exports.linkPreparedModulesAsync = linkPreparedModulesAsync;
 const node_path_1 = __importDefault(require("node:path"));
 const constants_1 = require("../config/constants");
 const host_1 = require("../harmony/providers/host");
 const generate_1 = require("../harmony/manifest/generate");
 const runtime_1 = require("../harmony/manifest/runtime");
 const errors_1 = require("../errors");
-const options_1 = require("../config/options");
 const link_1 = require("../harmony/rnoh/link");
 const stageProject_1 = require("../harmony/transaction/stageProject");
 const publish_1 = require("../harmony/transaction/publish");
 const previousState_1 = require("../harmony/transaction/previousState");
-const verify_1 = require("./verify");
 const values_1 = require("../utilities/values");
-const materialize_1 = require("../harmony/materialize");
+const prepare_1 = require("./prepare");
 function buildPublishEntries(staging, hostProviderSource, manifest) {
     return [
         ...Object.entries(constants_1.RnohArtifacts).map(([name, relative]) => ({
@@ -34,30 +33,9 @@ function buildPublishEntries(staging, hostProviderSource, manifest) {
         },
     ];
 }
-async function linkModulesAsync(rawOptions) {
-    const options = await (0, options_1.normalizeOptionsAsync)(rawOptions);
-    if (typeof rawOptions.harmonyProjectPath !== 'string' || !rawOptions.harmonyProjectPath) {
-        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'link requires harmonyProjectPath.', { stage: 'link' });
-    }
-    const verify = await (0, verify_1.verifyModulesAsync)((rawOptions.modules !== undefined
-        ? { modules: rawOptions.modules }
-        : { ...options, searchResult: rawOptions.searchResult }));
-    (0, verify_1.assertVerificationSucceeded)(verify, 'link');
-    const modules = verify.modules;
-    const pendingSource = modules.filter(module => module.artifact.kind === 'local-source');
-    if (pendingSource.length > 0) {
-        if (pendingSource.some(module => module.source !== 'nativeModulesDir')) {
-            throw new errors_1.HarmonyAutolinkingError('SOURCE_ARTIFACT_MATERIALIZATION_REQUIRED', 'Only nativeModulesDir modules may build a local Harmony HAR.', { stage: 'link', details: pendingSource.map(module => module.packageName).sort() });
-        }
-        await (0, materialize_1.materializeLocalSourcesAsync)(pendingSource, {
-            dependencies: modules,
-            projectRoot: options.projectRoot,
-            timeoutMs: rawOptions.timeoutMs,
-            outputLimit: rawOptions.outputLimit,
-            env: rawOptions.env,
-        });
-    }
-    const hostProviderSource = (0, host_1.renderArkTsHostProviderSource)(modules);
+async function linkPreparedModulesAsync(raw, prepared) {
+    const { options, modules, diagnostics } = prepared;
+    const provider = (0, host_1.renderArkTsHostProviderSource)(modules);
     let staging;
     let failure;
     let cleanupWarning;
@@ -66,16 +44,16 @@ async function linkModulesAsync(rawOptions) {
         const previous = await (0, previousState_1.readPreviousAutolinkingStateAsync)(options.projectRoot);
         if (previous.warning) {
             warnings.push(previous.warning);
-            (0, values_1.emitLog)(rawOptions.logger, 'warn', previous.warning.message, previous.warning);
+            (0, values_1.emitLog)(raw.logger, 'warn', previous.warning.message, previous.warning);
         }
         staging = await (0, stageProject_1.stageProjectAsync)({
             projectRoot: options.projectRoot,
-            harmonyProjectPath: rawOptions.harmonyProjectPath,
-            nodeModulesPath: rawOptions.nodeModulesPath,
+            harmonyProjectPath: raw.harmonyProjectPath,
+            nodeModulesPath: raw.nodeModulesPath,
             modules,
             buildType: options.buildType,
             previousManagedOhpmPackageNames: previous.managedOhpmPackageNames,
-            rnohCliPackageJsonPath: rawOptions.rnohCliPackageJsonPath,
+            rnohCliPackageJsonPath: raw.rnohCliPackageJsonPath,
         });
         staging.rnohArtifacts = await (0, link_1.linkRnohAsync)({
             ...staging,
@@ -83,11 +61,11 @@ async function linkModulesAsync(rawOptions) {
             buildType: options.buildType,
             exclude: staging.rnohRuntimePackages,
             commandNodeModulesPath: staging.sourceNodeModulesPath,
-            reactNativeExecutable: rawOptions.reactNativeExecutable,
-            rnohCliPackageJsonPath: rawOptions.rnohCliPackageJsonPath,
-            timeoutMs: rawOptions.timeoutMs,
-            outputLimit: rawOptions.outputLimit,
-            env: rawOptions.env,
+            reactNativeExecutable: raw.reactNativeExecutable,
+            rnohCliPackageJsonPath: raw.rnohCliPackageJsonPath,
+            timeoutMs: raw.timeoutMs,
+            outputLimit: raw.outputLimit,
+            env: raw.env,
         });
         const harmonyRoot = node_path_1.default.relative(staging.projectRoot, staging.harmonyProjectPath)
             .split(node_path_1.default.sep).join('/');
@@ -100,7 +78,19 @@ async function linkModulesAsync(rawOptions) {
         const published = await (0, publish_1.publishArtifactsAsync)({
             allowedRoot: staging.projectRoot,
             lockPath: node_path_1.default.join(staging.projectRoot, '.expo/harmony/autolinking.lock'),
-            files: buildPublishEntries(staging, hostProviderSource, manifest),
+            files: [
+                ...buildPublishEntries(staging, provider, manifest),
+                ...(raw.moduleBuilds !== undefined
+                    ? [{
+                            target: node_path_1.default.join(staging.projectRoot, '.expo/harmony/module-build-options.json'),
+                            content: JSON.stringify({
+                                schemaVersion: 1,
+                                moduleBuilds: raw.moduleBuilds,
+                                moduleBuildSettings: raw.moduleBuildSettings,
+                            }, null, 2) + '\n',
+                        }]
+                    : []),
+            ],
             stale: previous.artifacts.filter(artifact => !managed.some((relative) => {
                 return artifact === node_path_1.default.join(staging.projectRoot, ...relative.split('/'));
             })),
@@ -112,10 +102,10 @@ async function linkModulesAsync(rawOptions) {
             managedArtifacts: [...managed],
             changedArtifacts: published.changed.map(target => node_path_1.default.relative(staging.projectRoot, target).split(node_path_1.default.sep).join('/')),
             unchangedArtifacts: published.unchanged.map(target => node_path_1.default.relative(staging.projectRoot, target).split(node_path_1.default.sep).join('/')),
-            diagnostics: verify.diagnostics,
+            diagnostics,
             warnings,
         };
-        (0, values_1.emitLog)(rawOptions.logger, 'info', 'Harmony autolinking completed.', {
+        (0, values_1.emitLog)(raw.logger, 'info', 'Harmony autolinking completed.', {
             moduleCount: result.modules.length,
             changedArtifactCount: result.changedArtifacts.length,
         });
@@ -123,7 +113,7 @@ async function linkModulesAsync(rawOptions) {
     }
     catch (error) {
         failure = error;
-        (0, values_1.emitLog)(rawOptions.logger, 'error', 'Harmony autolinking failed.', {
+        (0, values_1.emitLog)(raw.logger, 'error', 'Harmony autolinking failed.', {
             code: error.code || 'ERR_EXPO_HARMONY_UNKNOWN',
             stage: error.stage || 'link',
         });
@@ -135,7 +125,7 @@ async function linkModulesAsync(rawOptions) {
                 const warning = { ...cleanup };
                 delete warning.cause;
                 warnings.push(warning);
-                (0, values_1.emitLog)(rawOptions.logger, 'warn', warning.message, warning);
+                (0, values_1.emitLog)(raw.logger, 'warn', warning.message, warning);
                 if (failure)
                     cleanupWarning = warning;
             }
@@ -151,3 +141,6 @@ async function linkModulesAsync(rawOptions) {
             : failure.details,
     });
 }
+async function linkModulesAsync(raw) {
+    return linkPreparedModulesAsync(raw, await (0, prepare_1.prepareModulesAsync)(raw));
+}

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

@@ -0,0 +1,15 @@
+import type { LinkOptions } from '../types';
+export declare function prepareModulesAsync(raw: LinkOptions): Promise<{
+    options: {
+        projectRoot: string;
+        platform: string;
+        searchPaths: string[];
+        nativeModulesDir: string;
+        exclude: string[];
+        include: string[];
+        moduleOverrides: Readonly<{}>;
+        buildType: any;
+    };
+    diagnostics: readonly import("../types").Diagnostic[];
+    modules: readonly import("../types").ModuleDescriptor[];
+}>;

package/build/src/autolinking/prepare.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareModulesAsync = prepareModulesAsync;
+const errors_1 = require("../errors");
+const options_1 = require("../config/options");
+const materialize_1 = require("../harmony/materialize");
+const configuredBuild_1 = require("../harmony/configuredBuild");
+const verify_1 = require("./verify");
+async function prepareModulesAsync(raw) {
+    const options = await (0, options_1.normalizeOptionsAsync)(raw);
+    if (typeof raw.harmonyProjectPath !== 'string' || !raw.harmonyProjectPath) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'link requires harmonyProjectPath.', { stage: 'link' });
+    }
+    const verify = await (0, verify_1.verifyModulesAsync)((raw.modules !== undefined
+        ? { modules: raw.modules }
+        : { ...options, searchResult: raw.searchResult }));
+    (0, verify_1.assertVerificationSucceeded)(verify, 'link');
+    const modules = verify.modules;
+    const pending = modules.filter(module => module.artifact.kind === 'local-source');
+    if (pending.length > 0) {
+        if (pending.some(module => module.source !== 'nativeModulesDir')) {
+            throw new errors_1.HarmonyAutolinkingError('SOURCE_ARTIFACT_MATERIALIZATION_REQUIRED', 'Only nativeModulesDir modules may build a local Harmony HAR.', { stage: 'link', details: pending.map(module => module.packageName).sort() });
+        }
+        await (0, materialize_1.materializeLocalSourcesAsync)(pending, {
+            dependencies: modules,
+            projectRoot: options.projectRoot,
+            timeoutMs: raw.timeoutMs,
+            outputLimit: raw.outputLimit,
+            env: raw.env,
+        });
+    }
+    return {
+        options,
+        diagnostics: verify.diagnostics,
+        modules: await (0, configuredBuild_1.buildConfiguredModulesAsync)(modules, {
+            ...raw, projectRoot: options.projectRoot, buildType: options.buildType,
+        }),
+    };
+}

package/build/src/autolinking/verify.js

@@ -224,6 +224,7 @@ function searchRecordFromDescriptor(descriptor, declared) {
             ? {
                 platforms: ['harmony'],
                 harmony: {
+                    ...(descriptor.harmony.buildOptionsFile ? { buildOptionsFile: descriptor.harmony.buildOptionsFile } : {}),
                     modules,
                     services,
                     ...Object.fromEntries(host_1.HostMetadataFields.map(field => [

package/build/src/commands/link.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerLinkCommand = registerLinkCommand;
 const link_1 = require("../autolinking/link");
+const prepare_1 = require("../autolinking/prepare");
 const autolinkingOptions_1 = require("./autolinkingOptions");
 const output_1 = require("./output");
 function registerLinkCommand(program, io) {
@@ -14,7 +15,7 @@ function registerLinkCommand(program, io) {
         .option('--output-limit <bytes>', 'per-stream output capture limit', autolinkingOptions_1.parsePositiveInt)
         .option('-j, --json', 'output results in the plain JSON format', false)
         .action(async (searchPaths, options) => {
-        (0, output_1.writeResult)(io, await (0, link_1.linkModulesAsync)({
+        const input = {
             ...(0, autolinkingOptions_1.toApiOptions)(options, searchPaths),
             harmonyProjectPath: options.harmonyProjectPath,
             nodeModulesPath: options.nodeModulesPath,
@@ -22,6 +23,8 @@ function registerLinkCommand(program, io) {
             rnohCliPackageJsonPath: options.rnohCliPackageJson,
             timeoutMs: options.timeoutMs,
             outputLimit: options.outputLimit,
-        }), options);
+        };
+        const prepared = await (0, prepare_1.prepareModulesAsync)(input);
+        (0, output_1.writeResult)(io, await (0, link_1.linkPreparedModulesAsync)(input, prepared), options);
     });
 }

package/build/src/harmony/configuredBuild.d.ts

@@ -0,0 +1,2 @@
+import type { LinkOptions, ModuleDescriptor } from '../types';
+export declare function buildConfiguredModulesAsync(modules: ReadonlyArray<ModuleDescriptor>, raw: LinkOptions): Promise<ReadonlyArray<ModuleDescriptor>>;

package/build/src/harmony/configuredBuild.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfiguredModulesAsync = buildConfiguredModulesAsync;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const json5_1 = __importDefault(require("json5"));
+const errors_1 = require("../errors");
+const values_1 = require("../utilities/values");
+const dependencies_1 = require("./ohpm/dependencies");
+const har_1 = require("./har");
+const materialize_1 = require("./materialize");
+const publish_1 = require("./transaction/publish");
+const Ignored = new Set(['.git', '.hvigor', '.cxx', '.native-build', 'native-deps', 'build', 'node_modules', 'oh_modules', 'local.properties', 'oh-package-lock.json5', 'BuildProfile.ets']);
+const InputsFile = '.expo/harmony/module-build-options.json';
+async function readBuildInputs(options) {
+    if (options.moduleBuilds !== undefined)
+        return options;
+    let content;
+    try {
+        content = await promises_1.default.readFile(node_path_1.default.join(options.projectRoot, InputsFile), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return options;
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Cannot read ${InputsFile}.`, {
+            cause: error,
+            stage: 'configured-module-build',
+        });
+    }
+    let saved;
+    try {
+        saved = JSON.parse(content);
+    }
+    catch (error) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Invalid ${InputsFile}; run Harmony prebuild again.`, {
+            cause: error,
+            stage: 'configured-module-build',
+        });
+    }
+    if (!saved || typeof saved !== 'object' || saved.schemaVersion !== 1 || !saved.moduleBuilds) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Invalid ${InputsFile}; run Harmony prebuild again.`, {
+            stage: 'configured-module-build',
+        });
+    }
+    return { ...options, moduleBuilds: saved.moduleBuilds, moduleBuildSettings: saved.moduleBuildSettings };
+}
+async function hashTree(hash, dir, depth = Infinity, metadataOnly = false) {
+    for (const entry of (await promises_1.default.readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name, 'en'))) {
+        if (Ignored.has(entry.name) || entry.name.endsWith('.har'))
+            continue;
+        const file = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory() && depth > 0) {
+            hash.update(entry.name + '/');
+            await hashTree(hash, file, depth - 1, metadataOnly);
+        }
+        else if (entry.isFile() && (!metadataOnly || /(?:package|sdk-pkg)\.json$/u.test(entry.name))) {
+            hash.update(entry.name + '\0').update(new Uint8Array(await promises_1.default.readFile(file)));
+        }
+    }
+}
+async function buildFingerprint(project, modules, options) {
+    const hash = node_crypto_1.default.createHash('sha256');
+    hash.update(new Uint8Array(await promises_1.default.readFile(__filename)));
+    hash.update(JSON.stringify([options.buildType, options.moduleBuildSettings]));
+    await hashTree(hash, project);
+    for (const { descriptor, mapping } of (0, dependencies_1.collectOhpmDeps)(modules)) {
+        const file = (0, dependencies_1.resolveOhpmSpecifier)(descriptor, mapping, { harmonyProjectPath: project });
+        hash.update(mapping.ohPackageName).update(new Uint8Array(await promises_1.default.readFile(node_path_1.default.resolve(project, file))));
+    }
+    const env = { ...process.env, ...options.env };
+    for (const key of Object.keys(env).sort()) {
+        if (/^(HARMONY_|DEVECO_|OHOS_)|^(PATH|CC|CXX|CFLAGS|CXXFLAGS|LDFLAGS)$/u.test(key))
+            hash.update(key + '=' + env[key]);
+    }
+    if (!env.DEVECO_SDK_HOME || !env.HARMONY_HVIGORW || !env.HARMONY_OHPM)
+        return null;
+    await hashTree(hash, env.DEVECO_SDK_HOME, 3, true);
+    for (const tool of [env.HARMONY_HVIGORW, env.HARMONY_OHPM]) {
+        hash.update(new Uint8Array(await promises_1.default.readFile(tool)));
+        const manifest = node_path_1.default.resolve(node_path_1.default.dirname(tool), '../package.json');
+        try {
+            hash.update(new Uint8Array(await promises_1.default.readFile(manifest)));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Cannot read build tool metadata: ${manifest}`, {
+                    cause: error,
+                    stage: 'configured-module-build',
+                });
+            }
+        }
+    }
+    return hash.digest('hex');
+}
+async function buildConfiguredModulesAsync(modules, raw) {
+    const options = await readBuildInputs(raw);
+    const builds = options.moduleBuilds ?? {};
+    if (!builds || typeof builds !== 'object' || Array.isArray(builds)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'moduleBuilds must be an object.', {
+            stage: 'configured-module-build',
+        });
+    }
+    const linked = [...modules];
+    for (const name of Object.keys(builds).sort()) {
+        const index = linked.findIndex(item => item.packageName === name);
+        if (index < 0) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Configured native module ${name} is not linked. Install it or remove its config plugin.`, {
+                stage: 'configured-module-build',
+            });
+        }
+        const item = linked[index];
+        const file = item.harmony.buildOptionsFile;
+        if (!item.arkTs || !file) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `${name} does not declare harmony.buildOptionsFile.`, {
+                stage: 'configured-module-build',
+            });
+        }
+        const source = await (0, values_1.resolveInsideAsync)(item.packageRoot, 'harmony', 'Harmony source project', { packageName: name, type: 'directory' });
+        const defaultsPath = await (0, values_1.resolveInsideAsync)(source, file, 'Harmony build options', { packageName: name, type: 'file' });
+        const defaults = JSON.parse(await promises_1.default.readFile(defaultsPath, 'utf8'));
+        const selected = builds[name];
+        if (!selected || typeof selected !== 'object' || Array.isArray(selected)) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Build options for ${name} must be an object.`, {
+                stage: 'configured-module-build',
+            });
+        }
+        for (const [key, value] of Object.entries(selected)) {
+            if (!Object.hasOwn(defaults, key) || !['boolean', 'string', 'number'].includes(typeof value)
+                || typeof value !== typeof defaults[key] || (typeof value === 'number' && !Number.isFinite(value))) {
+                throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Invalid build option ${name}.${key}.`, {
+                    stage: 'configured-module-build',
+                });
+            }
+        }
+        const root = await promises_1.default.realpath(options.projectRoot);
+        const cache = await (0, values_1.resolveInsideAsync)(root, '.expo/harmony/module-builds', 'Module build directory', { mustExist: false });
+        let dir = root;
+        for (const segment of ['.expo', 'harmony', 'module-builds']) {
+            dir = node_path_1.default.join(dir, segment);
+            try {
+                await promises_1.default.mkdir(dir);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST') {
+                    throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Cannot create module build directory: ${dir}`, {
+                        cause: error,
+                        stage: 'configured-module-build',
+                    });
+                }
+            }
+            const stat = await promises_1.default.lstat(dir);
+            if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'Module build directory must not be a symbolic link.', {
+                    stage: 'configured-module-build',
+                });
+            }
+        }
+        const temp = await promises_1.default.mkdtemp(node_path_1.default.join(cache, 'build-'));
+        const project = node_path_1.default.join(temp, 'harmony');
+        try {
+            await promises_1.default.cp(source, project, {
+                recursive: true,
+                dereference: true,
+                filter: async (entry) => {
+                    if (Ignored.has(node_path_1.default.basename(entry)) || entry.endsWith('.har'))
+                        return false;
+                    if (!(0, values_1.isPathInside)(item.packageRoot, await promises_1.default.realpath(entry))) {
+                        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Harmony source link escapes ${name}: ${node_path_1.default.relative(source, entry)}`, {
+                            stage: 'configured-module-build',
+                        });
+                    }
+                    return true;
+                },
+            });
+            await promises_1.default.writeFile(node_path_1.default.join(project, file), JSON.stringify({ ...defaults, ...selected }, null, 2) + '\n');
+            const profilePath = node_path_1.default.join(project, 'build-profile.json5');
+            const profile = json5_1.default.parse(await promises_1.default.readFile(profilePath, 'utf8'));
+            const library = profile.modules?.find(entry => node_path_1.default.normalize(entry.srcPath) === 'library');
+            const product = profile.app?.products?.find(entry => entry.name === 'default');
+            if (!library || !product || !/^[A-Za-z][A-Za-z0-9_]*$/u.test(library.name)) {
+                throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `${name} must declare a library module and default product in harmony/build-profile.json5.`, {
+                    stage: 'configured-module-build',
+                });
+            }
+            const settings = options.moduleBuildSettings;
+            if (settings) {
+                if (!Array.isArray(settings.abiFilters) || settings.abiFilters.length === 0
+                    || settings.abiFilters.some(abi => !['arm64-v8a', 'x86_64'].includes(abi))
+                    || ![settings.compatibleSdkVersion, settings.targetSdkVersion].every(value => typeof value === 'string' && value.length > 0)) {
+                    throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'Invalid moduleBuildSettings; run Harmony prebuild again.', {
+                        stage: 'configured-module-build',
+                    });
+                }
+                product.compatibleSdkVersion = settings.compatibleSdkVersion;
+                product.targetSdkVersion = settings.targetSdkVersion;
+                const file = node_path_1.default.join(project, 'library/build-profile.json5');
+                const build = json5_1.default.parse(await promises_1.default.readFile(file, 'utf8'));
+                if (build.buildOption?.externalNativeOptions) {
+                    build.buildOption.externalNativeOptions.abiFilters = settings.abiFilters;
+                }
+                await promises_1.default.writeFile(file, JSON.stringify(build, null, 2) + '\n');
+            }
+            await promises_1.default.writeFile(profilePath, JSON.stringify(profile, null, 2) + '\n');
+            const deps = linked.filter(module => module.packageName !== name);
+            const key = await buildFingerprint(project, deps, options);
+            const cached = key ? node_path_1.default.join(cache, `${key}.har`) : null;
+            if (cached && await (0, materialize_1.isNonEmptyRegularHarAsync)(cached, cache, name)) {
+                try {
+                    const expected = JSON.parse(await promises_1.default.readFile(cached + '.json', 'utf8')).sha256;
+                    const actual = node_crypto_1.default.createHash('sha256').update(new Uint8Array(await promises_1.default.readFile(cached))).digest('hex');
+                    if (expected === actual) {
+                        linked[index] = { ...item, arkTs: { ...item.arkTs, builtHarPath: cached } };
+                        continue;
+                    }
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT' && !(error instanceof SyntaxError)) {
+                        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `Cannot inspect cached HAR for ${name}.`, {
+                            cause: error,
+                            stage: 'configured-module-build',
+                        });
+                    }
+                }
+            }
+            const manifestPath = node_path_1.default.join(project, 'oh-package.json5');
+            const manifest = json5_1.default.parse(await promises_1.default.readFile(manifestPath, 'utf8'));
+            const overrides = {};
+            const versions = {};
+            for (const { descriptor, mapping } of (0, dependencies_1.collectOhpmDeps)(deps)) {
+                overrides[mapping.ohPackageName] = (0, dependencies_1.resolveOhpmSpecifier)(descriptor, mapping, { harmonyProjectPath: project });
+                versions[mapping.ohPackageName] = descriptor.packageVersion;
+            }
+            await promises_1.default.writeFile(manifestPath, JSON.stringify({ ...manifest, overrides: { ...manifest.overrides, ...overrides } }, null, 2) + '\n');
+            const build = {
+                executable: 'hvigorw', cwd: project,
+                args: ['--mode', 'module', '-p', `module=${library.name}@default`, '-p', 'product=default', '-p', `buildMode=${options.buildType ?? 'debug'}`, '--no-daemon', 'assembleHar'],
+            };
+            for (const step of (0, materialize_1.fixedLocalSourceBuildSteps)(build))
+                await (0, materialize_1.runFixedBuildStepAsync)(step, name, options);
+            const output = node_path_1.default.join(project, 'library/build/default/outputs/default', `${library.name}.har`);
+            if (!await (0, materialize_1.isNonEmptyRegularHarAsync)(output, project, name)) {
+                throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `${name}: Hvigor did not produce a HAR.`, {
+                    stage: 'configured-module-build',
+                });
+            }
+            const sourceManifest = json5_1.default.parse(await promises_1.default.readFile(node_path_1.default.join(project, 'library/oh-package.json5'), 'utf8'));
+            await (0, har_1.sanitizeHarmonyHar)(output, { sourceManifest, workspaceVersions: versions });
+            const digest = node_crypto_1.default.createHash('sha256').update(new Uint8Array(await promises_1.default.readFile(output))).digest('hex');
+            const target = cached || node_path_1.default.join(cache, `${digest}.har`);
+            await (0, publish_1.publishArtifactsAsync)({
+                allowedRoot: root, lockPath: node_path_1.default.join(cache, 'publish.lock'), files: [{ source: output, target }, { content: JSON.stringify({ sha256: digest }) + '\n', target: target + '.json' }],
+            });
+            linked[index] = { ...item, arkTs: { ...item.arkTs, builtHarPath: target } };
+        }
+        finally {
+            await promises_1.default.rm(temp, { recursive: true, force: true });
+        }
+    }
+    return linked;
+}

package/build/src/harmony/har.d.ts

@@ -0,0 +1,6 @@
+export declare function sanitizeHarmonyHar(file: any, { sourceManifest: source, workspaceVersions: versions, moduleRoot, }?: {
+    sourceManifest?: Record<string, unknown>;
+    workspaceVersions?: Record<string, string>;
+    moduleRoot?: string;
+}): Promise<void>;
+export declare function assertPortableHarmonyHarSync(harPath: any): void;