@expo-harmony/expo-modules-autolinking 55.0.25-harmony.2 → 55.0.25-harmony.4

package/README.md

@@ -4,9 +4,15 @@
 
 为 HarmonyOS 上的 React Native 应用提供 Expo Modules 和 RNOH 原生模块自动链接能力，与官方同版本的 expo-modules-autolinking 配套使用。
 
+## 安装
+
+```bash
+npm install @expo-harmony/expo-modules-autolinking @react-native-oh/react-native-harmony-cli@^0.84.1
+```
+
 ## Author
 
 **expo-harmony** © [Baoshuo](https://github.com/renbaoshuo), Released under the MIT License.<br>
 Authored and maintained by Baoshuo with help from [contributors](https://github.com/renbaoshuo/expo-harmony/contributors).
 
-> [Personal Website](https://baoshuo.ren) · [Blog](https://blog.baoshuo.ren) · GitHub [@renbaoshuo](https://github.com/renbaoshuo) · Twitter [@baoshuo](https://twitter.com/baoshuo)
+> [Personal Website](https://baoshuo.ren) · [Blog](https://blog.baoshuo.ren) · GitHub [@renbaoshuo](https://github.com/renbaoshuo) · Twitter [@renbaoshuo](https://twitter.com/renbaoshuo)

package/build/index.d.ts

@@ -6,3 +6,5 @@ import { verifyModulesAsync } from './src/autolinking/verify';
 import { normalizeHarmonyModuleMetadata } from './src/metadata/schema';
 export { canonicalizeAutolinkingArtifacts, linkModulesAsync, 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,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.linkModulesAsync = exports.canonicalizeAutolinkingArtifacts = void 0;
 const link_1 = require("./src/autolinking/link");
 Object.defineProperty(exports, "linkModulesAsync", { enumerable: true, get: function () { return link_1.linkModulesAsync; } });
 const canonicalize_1 = require("./src/harmony/persistence/canonicalize");
@@ -13,3 +13,7 @@ const verify_1 = require("./src/autolinking/verify");
 Object.defineProperty(exports, "verifyModulesAsync", { enumerable: true, get: function () { return verify_1.verifyModulesAsync; } });
 const schema_1 = require("./src/metadata/schema");
 Object.defineProperty(exports, "normalizeHarmonyModuleMetadata", { enumerable: true, get: function () { return schema_1.normalizeHarmonyModuleMetadata; } });
+var runtime_1 = require("./src/harmony/manifest/runtime");
+Object.defineProperty(exports, "createNativeModuleContracts", { enumerable: true, get: function () { return runtime_1.createNativeModuleContracts; } });
+var manifest_1 = require("./src/harmony/manifest");
+Object.defineProperty(exports, "ohpmDependenciesFromManifest", { enumerable: true, get: function () { return manifest_1.ohpmDependenciesFromManifest; } });

package/build/runtime.d.ts

@@ -0,0 +1,67 @@
+export interface HarmonyNativeModule {
+    packageName: string;
+    packageVersion: string;
+    modules: string[];
+    services: string[];
+    registrations: string[];
+    artifacts: string[];
+}
+export interface HarmonyRuntimeContract {
+    schemaVersion: 1;
+    platform: 'harmony';
+    runtimeVersion: string;
+    development: boolean;
+    expo: string;
+    expoModulesCore: string;
+    rnoh: string;
+    react: string;
+    hermes: string;
+    engine: 'hermes-v1';
+    bundleFormat: 'js-source';
+    renderer: 'rnoh';
+    modules: HarmonyNativeModule[];
+    config: {
+        nativeCompiler: string;
+        targetApiVersion: number;
+        compatibleApiVersion: number;
+        permissions: string[];
+        querySchemes: string[];
+        backgroundModes: string[];
+        abiFilters: string[];
+    };
+}
+export interface HarmonyCompatibilityIssue {
+    code: string;
+    field: string;
+    message: string;
+}
+export declare class HarmonyCompatibilityError extends Error {
+    readonly issues: HarmonyCompatibilityIssue[];
+    readonly code = "ERR_HARMONY_INCOMPATIBLE";
+    constructor(issues: HarmonyCompatibilityIssue[]);
+}
+export declare function validateHarmonyRuntime(value: unknown): HarmonyCompatibilityIssue[];
+export declare function checkHarmonyCompatibility(client: unknown, requirements: unknown): HarmonyCompatibilityIssue[];
+export declare function assertHarmonyCompatibility(client: unknown, requirements: unknown): asserts requirements is HarmonyRuntimeContract;
+export interface HarmonyDevelopmentManifest {
+    id: string;
+    createdAt: string;
+    metadata: Record<string, string>;
+    assets: unknown[];
+    runtimeVersion: string;
+    launchAsset: {
+        key: 'bundle';
+        contentType: 'application/javascript';
+        url: string;
+    };
+    extra: {
+        expoClient: Record<string, unknown>;
+        expoGo: Record<string, unknown>;
+        harmony: {
+            projectId: string;
+            manifestUrl: string;
+            requirements: HarmonyRuntimeContract;
+        };
+    };
+}
+export declare function assertHarmonyDevelopmentManifest(client: unknown, value: unknown): asserts value is HarmonyDevelopmentManifest;

package/build/runtime.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyCompatibilityError = void 0;
+exports.validateHarmonyRuntime = validateHarmonyRuntime;
+exports.checkHarmonyCompatibility = checkHarmonyCompatibility;
+exports.assertHarmonyCompatibility = assertHarmonyCompatibility;
+exports.assertHarmonyDevelopmentManifest = assertHarmonyDevelopmentManifest;
+class HarmonyCompatibilityError extends Error {
+    issues;
+    code = 'ERR_HARMONY_INCOMPATIBLE';
+    constructor(issues) {
+        super(issues.map(issue => `[${issue.code}] ${issue.message}`).join('\n'));
+        this.issues = issues;
+        this.name = 'HarmonyCompatibilityError';
+    }
+}
+exports.HarmonyCompatibilityError = HarmonyCompatibilityError;
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function token(value) {
+    return typeof value === 'string' && /^[A-Za-z0-9@][A-Za-z0-9@._+:()/-]{0,199}$/.test(value)
+        && !value.includes('://') && !value.includes('..') && !/^[A-Za-z]:/.test(value);
+}
+function strings(value) {
+    return Array.isArray(value) && value.every(token) && new Set(value).size === value.length;
+}
+const Versions = ['runtimeVersion', 'expo', 'expoModulesCore', 'rnoh', 'react', 'hermes'];
+const Settings = ['permissions', 'querySchemes', 'backgroundModes', 'abiFilters'];
+function validateHarmonyRuntime(value) {
+    if (!record(value))
+        return [{ code: 'INVALID_CONTRACT', field: '', message: 'Runtime contract must be an object.' }];
+    const issues = [];
+    for (const [field, expected] of Object.entries({ schemaVersion: 1, platform: 'harmony', engine: 'hermes-v1', bundleFormat: 'js-source', renderer: 'rnoh' })) {
+        if (value[field] !== expected) {
+            issues.push({ code: field === 'platform' ? 'PLATFORM_MISMATCH' : 'INVALID_CONTRACT', field, message: `${field} must be ${expected}.` });
+        }
+    }
+    if (typeof value.development !== 'boolean') {
+        issues.push({ code: 'INVALID_CONTRACT', field: 'development', message: 'development must describe native development support.' });
+    }
+    for (const field of Versions) {
+        if (field === 'runtimeVersion' ? typeof value[field] !== 'string' || !value[field] : !token(value[field])) {
+            issues.push({ code: 'INVALID_CONTRACT', field, message: `${field} must be an explicit version.` });
+        }
+    }
+    if (!Array.isArray(value.modules)) {
+        issues.push({ code: 'INVALID_CONTRACT', field: 'modules', message: 'Native modules must be an array.' });
+    }
+    else {
+        const names = new Set();
+        for (const module of value.modules) {
+            if (!record(module) || !token(module.packageName) || !token(module.packageVersion)
+                || !strings(module.modules) || !strings(module.services) || !strings(module.registrations)
+                || !strings(module.artifacts) || module.artifacts.some(hash => !/^[a-f0-9]{64}$/.test(hash))
+                || names.has(module.packageName)) {
+                issues.push({ code: 'INVALID_CONTRACT', field: 'modules', message: 'Invalid or duplicate native module contract.' });
+            }
+            else {
+                names.add(module.packageName);
+            }
+        }
+    }
+    const config = value.config;
+    if (!record(config) || !token(config.nativeCompiler) || !Settings.every(field => strings(config[field]))
+        || !Number.isInteger(config.targetApiVersion) || Number(config.targetApiVersion) < 13
+        || !Number.isInteger(config.compatibleApiVersion) || Number(config.compatibleApiVersion) < 13
+        || Number(config.compatibleApiVersion) > Number(config.targetApiVersion)
+        || (Array.isArray(config.abiFilters) && config.abiFilters.length === 0)) {
+        issues.push({ code: 'INVALID_CONTRACT', field: 'config', message: 'Invalid native build configuration.' });
+    }
+    return issues;
+}
+function checkHarmonyCompatibility(client, requirements) {
+    const issues = [
+        ...validateHarmonyRuntime(client).map(issue => ({ ...issue, field: `client.${issue.field}` })),
+        ...validateHarmonyRuntime(requirements).map(issue => ({ ...issue, field: `requirements.${issue.field}` })),
+    ];
+    if (issues.length > 0)
+        return issues;
+    const available = client;
+    const required = requirements;
+    for (const field of Versions) {
+        if (available[field] !== required[field]) {
+            issues.push({ code: 'RUNTIME_MISMATCH', field, message: `${field}: project requires ${required[field]}, client provides ${available[field]}. Rebuild or select a matching client.` });
+        }
+    }
+    if (required.development && !available.development) {
+        issues.push({ code: 'CONFIG_MISMATCH', field: 'development', message: 'This client was built without native development support. Use a debug client for development manifests.' });
+    }
+    for (const module of required.modules) {
+        const found = available.modules.find(item => item.packageName === module.packageName);
+        if (!found) {
+            issues.push({ code: 'MISSING_NATIVE_MODULE', field: module.packageName, message: `Client is missing native package ${module.packageName}. Rebuild the client with this package.` });
+            continue;
+        }
+        if (found.packageVersion !== module.packageVersion
+            || ['modules', 'services', 'registrations', 'artifacts'].some((field) => {
+                const left = found[field];
+                const right = module[field];
+                return left.length !== right.length || right.some(item => !left.includes(item));
+            })) {
+            issues.push({ code: 'NATIVE_MODULE_MISMATCH', field: module.packageName, message: `Native contract differs for ${module.packageName}. Rebuild or select a matching client.` });
+        }
+    }
+    for (const field of ['nativeCompiler', 'targetApiVersion', 'compatibleApiVersion']) {
+        if (available.config[field] !== required.config[field]) {
+            issues.push({ code: 'CONFIG_MISMATCH', field, message: `${field}: project requires ${required.config[field]}, client provides ${available.config[field]}.` });
+        }
+    }
+    for (const field of Settings) {
+        for (const item of required.config[field]) {
+            if (!available.config[field].includes(item)) {
+                issues.push({ code: 'CONFIG_MISMATCH', field, message: `Client build is missing ${field}: ${item}. Rebuild the client with this configuration.` });
+            }
+        }
+    }
+    return issues;
+}
+function assertHarmonyCompatibility(client, requirements) {
+    const issues = checkHarmonyCompatibility(client, requirements);
+    if (issues.length > 0)
+        throw new HarmonyCompatibilityError(issues);
+}
+function assertHarmonyDevelopmentManifest(client, value) {
+    if (!record(value) || typeof value.id !== 'string'
+        || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(value.id)
+        || typeof value.createdAt !== 'string' || !Number.isFinite(Date.parse(value.createdAt))
+        || !record(value.metadata) || !Object.values(value.metadata).every(item => typeof item === 'string')
+        || !Array.isArray(value.assets) || value.assets.length !== 0 || !record(value.launchAsset)
+        || value.launchAsset.key !== 'bundle' || value.launchAsset.contentType !== 'application/javascript'
+        || typeof value.launchAsset.url !== 'string' || !record(value.extra) || !record(value.extra.expoClient)
+        || !record(value.extra.expoGo) || !record(value.extra.harmony)
+        || typeof value.extra.harmony.projectId !== 'string' || !value.extra.harmony.projectId
+        || typeof value.extra.harmony.manifestUrl !== 'string') {
+        throw new HarmonyCompatibilityError([{ code: 'INVALID_MANIFEST', field: '', message: 'Expected an Expo development JS source manifest with Harmony requirements.' }]);
+    }
+    const harmony = value.extra.harmony;
+    assertHarmonyCompatibility(client, harmony.requirements);
+    const origin = /^(https?:\/\/(?:[A-Za-z0-9.-]+|\[[A-Fa-f0-9:.]+\])(?::[0-9]{1,5})?)\/(?:manifest|index\.exp)?\?platform=harmony$/.exec(harmony.manifestUrl)?.[1];
+    const bundle = value.launchAsset.url;
+    const query = bundle.split('?')[1]?.split('&') || [];
+    if (value.runtimeVersion !== harmony.requirements.runtimeVersion || !origin
+        || !bundle.startsWith(`${origin}/`) || !bundle.split('?')[0].endsWith('.bundle')
+        || bundle.includes('#') || query.filter(item => item.startsWith('platform=')).join() !== 'platform=harmony'
+        || query.filter(item => item.startsWith('transform.bytecode=')).join() !== 'transform.bytecode=0'
+        || query.filter(item => item.startsWith('dev=')).join() !== 'dev=true'
+        || query.filter(item => item.startsWith('transform.engine=')).join() !== 'transform.engine=hermes') {
+        throw new HarmonyCompatibilityError([{ code: 'INVALID_MANIFEST', field: 'launchAsset', message: 'Manifest and bundle must use the same HTTP(S) origin, runtime, Harmony platform, and development JS source format.' }]);
+    }
+}

package/build/src/autolinking/link.js

@@ -8,6 +8,7 @@ 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");
@@ -49,6 +50,7 @@ async function linkModulesAsync(rawOptions) {
             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,
@@ -93,6 +95,7 @@ async function linkModulesAsync(rawOptions) {
         const manifest = (0, generate_1.serializeManifest)(modules, {
             buildType: options.buildType,
             managedArtifacts: managed,
+            runtimeModules: (0, runtime_1.createNativeModuleContracts)(modules),
         });
         const published = await (0, publish_1.publishArtifactsAsync)({
             allowedRoot: staging.projectRoot,

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

@@ -1,4 +1,4 @@
 import type { ModuleDescriptor, ResolveOptions } from '../types';
-declare function compareModuleDescriptors(left: any, right: any): 1 | -1 | 0;
+declare function compareModuleDescriptors(left: any, right: any): 1 | 0 | -1;
 declare function resolveModulesAsync(options?: ResolveOptions): Promise<ModuleDescriptor[]>;
 export { compareModuleDescriptors, resolveModulesAsync, };

package/build/src/autolinking/verify.js

@@ -183,9 +183,14 @@ function searchRecordFromDescriptor(descriptor, declared) {
         });
     }
     const host = host_1.HostMetadataFields.some(field => descriptor.expo[field]?.length > 0);
-    const modules = Array.isArray(descriptor.harmony.modules)
-        ? [...descriptor.harmony.modules]
-        : [];
+    if (!Array.isArray(descriptor.harmony.modules) || !Array.isArray(descriptor.harmony.services)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'descriptor.harmony must declare module and service class lists.', {
+            packageName: descriptor.packageName,
+            stage: 'verify',
+        });
+    }
+    const modules = [...descriptor.harmony.modules];
+    const services = [...descriptor.harmony.services];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const rnoh = {};
     if (descriptor.rnoh.ohPackageName !== undefined) {
@@ -214,12 +219,13 @@ function searchRecordFromDescriptor(descriptor, declared) {
         packageVersion: descriptor.packageVersion,
         packageRoot: descriptor.packageRoot,
         source: descriptor.source,
-        supportsHarmony: modules.length > 0 || host,
-        expoModuleConfig: modules.length > 0 || host
+        supportsHarmony: modules.length > 0 || services.length > 0 || host,
+        expoModuleConfig: modules.length > 0 || services.length > 0 || host
             ? {
                 platforms: ['harmony'],
                 harmony: {
                     modules,
+                    services,
                     ...Object.fromEntries(host_1.HostMetadataFields.map(field => [
                         field,
                         [...(descriptor.expo[field] || [])],
@@ -318,6 +324,16 @@ async function verifyModulesAsync(options = {}) {
     }
     descriptors.sort(resolve_1.compareModuleDescriptors);
     diagnostics.push(...collectDescriptorConflicts(descriptors));
+    if (descriptors.some(module => module.packageName === '@expo-harmony/expo-modules-core')
+        && !descriptors.some(module => module.packageName === '@expo-harmony/expo')) {
+        diagnostics.push({
+            severity: 'error',
+            code: 'ERR_EXPO_HARMONY_HOST_NOT_FOUND',
+            message: 'Install @expo-harmony/expo to provide the native Expo host and module registration entry.',
+            packageName: '@expo-harmony/expo',
+            stage: 'verify',
+        });
+    }
     if (searchResult) {
         const seen = new Map();
         for (const descriptor of descriptors) {

package/build/src/config/constants.d.ts

@@ -1,7 +1,7 @@
 declare const Platform = "harmony";
 declare const RnohCliPackage = "@react-native-oh/react-native-harmony-cli";
 declare const ToolVersion: any;
-declare const ManifestSchemaVersion = 3;
+declare const ManifestSchemaVersion = 4;
 declare const RnohArtifacts: Readonly<{
     etsFactory: "entry/src/main/ets/RNOHPackagesFactory.ets";
     cppFactory: "entry/src/main/cpp/RNOHPackagesFactory.h";

package/build/src/config/constants.js

@@ -13,7 +13,7 @@ const RnohCliPackage = '@react-native-oh/react-native-harmony-cli';
 exports.RnohCliPackage = RnohCliPackage;
 const ToolVersion = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.resolve(__dirname, '../../../package.json'), 'utf8')).version;
 exports.ToolVersion = ToolVersion;
-const ManifestSchemaVersion = 3;
+const ManifestSchemaVersion = 4;
 exports.ManifestSchemaVersion = ManifestSchemaVersion;
 const RnohArtifacts = Object.freeze({
     etsFactory: 'entry/src/main/ets/RNOHPackagesFactory.ets',

package/build/src/harmony/manifest/generate.js

@@ -4,6 +4,7 @@ exports.createManifest = createManifest;
 exports.serializeManifest = serializeManifest;
 const constants_1 = require("../../config/constants");
 const values_1 = require("../../utilities/values");
+const host_1 = require("../../metadata/host");
 function cloneOhPackageName(value) {
     if (Array.isArray(value))
         return value.map(mapping => ({ ...mapping }));
@@ -18,11 +19,10 @@ function createManifestEntry(descriptor) {
         source: descriptor.source,
         harmony: {
             modules: [...descriptor.harmony.modules],
+            services: [...descriptor.harmony.services],
         },
         ...(descriptor.arkTs ? { arkTs: { ...descriptor.arkTs } } : {}),
-        expo: {
-            rootViewComponents: [...descriptor.expo.rootViewComponents],
-        },
+        expo: Object.fromEntries(host_1.HostMetadataFields.map(field => [field, [...descriptor.expo[field]]])),
         rnoh: {
             ...(descriptor.rnoh.ohPackageName !== undefined
                 ? { ohPackageName: cloneOhPackageName(descriptor.rnoh.ohPackageName) }
@@ -45,6 +45,7 @@ function createManifest(modules, options = {}) {
         schemaVersion: constants_1.ManifestSchemaVersion,
         platform: constants_1.Platform,
         buildType,
+        ...(options.runtimeModules ? { runtimeModules: options.runtimeModules } : {}),
         modules: modules.map(descriptor => createManifestEntry(descriptor)),
         managedArtifacts: [...(options.managedArtifacts || constants_1.ManagedArtifacts)],
     };

package/build/src/harmony/manifest/index.js

@@ -11,7 +11,13 @@ const errors_1 = require("../../errors");
 const dependencies_1 = require("../ohpm/dependencies");
 const schema_1 = require("../../metadata/schema");
 const values_1 = require("../../utilities/values");
+const host_1 = require("../../metadata/host");
 const ModuleSources = new Set(['dependency', 'searchPath', 'nativeModulesDir', 'reactNativeProjectConfig']);
+function isClassList(value) {
+    return Array.isArray(value)
+        && value.every(name => typeof name === 'string' && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name))
+        && new Set(value).size === value.length;
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function validateManifest(manifest, options = {}) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -38,21 +44,30 @@ function validateManifest(manifest, options = {}) {
             || typeof entry.packageLinkPath !== 'string'
             || !node_path_1.default.isAbsolute(entry.packageLinkPath)
             || !ModuleSources.has(entry.source)
-            || (entry.harmony !== undefined && (!(0, values_1.isObject)(entry.harmony)
-                || !Array.isArray(entry.harmony.modules)
-                || entry.harmony.modules.some(moduleClass => typeof moduleClass !== 'string' || !moduleClass)))
+            || !(0, values_1.isObject)(entry.harmony)
+            || !isClassList(entry.harmony.modules)
+            || !isClassList(entry.harmony.services)
             || (entry.arkTs !== undefined && (!(0, values_1.isObject)(entry.arkTs)
                 || entry.arkTs.harPath !== 'harmony/library.har'
                 || !(0, schema_1.isValidOhpmPackageName)(entry.arkTs.ohPackageName)))
-            || (entry.harmony?.modules.length > 0 && !(0, values_1.isObject)(entry.arkTs))
+            || ((entry.harmony.modules.length > 0 || entry.harmony.services.length > 0) && !(0, values_1.isObject)(entry.arkTs))
             || !(0, values_1.isObject)(entry.expo)
-            || !Array.isArray(entry.expo.rootViewComponents)
+            || !isClassList(entry.expo.rootViewComponents)
+            || !host_1.HostMetadataFields.every(field => isClassList(entry.expo[field] ?? []))
+            || (host_1.HostMetadataFields.some(field => entry.expo[field]?.length > 0) && !(0, values_1.isObject)(entry.arkTs))
             || !(0, values_1.isObject)(entry.rnoh)
             || !Array.isArray(entry.rnoh.harPaths)) {
             throw new errors_1.HarmonyAutolinkingError('INVALID_MANIFEST', `Harmony autolinking manifest module ${index} is invalid.`, { details: options.file ? { file: options.file } : undefined, stage: 'manifest' });
         }
     }
-    return structuredClone(candidate);
+    // Schema 4 manifests generated before lifecycle contributions remain readable
+    // for stale dependency cleanup. New manifests always contain the full lists.
+    const normalized = structuredClone(candidate);
+    normalized.modules.forEach((entry) => {
+        for (const field of host_1.HostMetadataFields)
+            entry.expo[field] ??= [];
+    });
+    return normalized;
 }
 function ohpmDependenciesFromManifest(manifest, options = {}) {
     const validated = validateManifest(manifest);

package/build/src/harmony/manifest/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { HarmonyNativeModule } from '../../../runtime';
+import type { ModuleDescriptor } from '../../types';
+export declare function createNativeModuleContracts(modules: readonly ModuleDescriptor[]): HarmonyNativeModule[];

package/build/src/harmony/manifest/runtime.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNativeModuleContracts = createNativeModuleContracts;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const tar_1 = __importDefault(require("tar"));
+const errors_1 = require("../../errors");
+function digest(file) {
+    if (!node_fs_1.default.statSync(file).isFile()) {
+        throw new errors_1.HarmonyAutolinkingError('RUNTIME_ARTIFACT', 'Native runtime artifacts must be regular files.', { stage: 'runtime-contract' });
+    }
+    const entries = [];
+    const names = new Set();
+    tar_1.default.t({
+        file,
+        sync: true,
+        strict: true,
+        onentry(entry) {
+            if (entry.type === 'Directory')
+                return;
+            if (entry.type !== 'File' || names.has(entry.path)) {
+                throw new errors_1.HarmonyAutolinkingError('RUNTIME_ARTIFACT', 'Native HARs must contain unique regular files.', { stage: 'runtime-contract' });
+            }
+            names.add(entry.path);
+            const hash = node_crypto_1.default.createHash('sha256');
+            entry.on('data', chunk => hash.update(chunk));
+            entry.on('end', () => entries.push(`${entry.path}\0${hash.digest('hex')}`));
+        },
+    });
+    if (entries.length === 0) {
+        throw new errors_1.HarmonyAutolinkingError('RUNTIME_ARTIFACT', 'Native HARs must not be empty.', { stage: 'runtime-contract' });
+    }
+    // Archive timestamps, owners, and entry order are not native runtime inputs.
+    return node_crypto_1.default.createHash('sha256').update(entries.sort().join('\0')).digest('hex');
+}
+function sourceDigest(root) {
+    const hash = node_crypto_1.default.createHash('sha256');
+    const ignored = new Set(['build', '.hvigor', '.cxx', 'oh_modules', 'node_modules', '.git', 'oh-package-lock.json5']);
+    const visit = (directory) => {
+        const entries = node_fs_1.default.readdirSync(directory, { withFileTypes: true })
+            .sort((left, right) => left.name < right.name ? -1 : 1);
+        for (const entry of entries) {
+            if (ignored.has(entry.name))
+                continue;
+            const file = node_path_1.default.join(directory, entry.name);
+            if (entry.isDirectory())
+                visit(file);
+            else if (entry.isFile() && /\.(ets|ts|cpp|c|h|hpp|cmake|json|json5|so|a)$|CMakeLists\.txt$/.test(entry.name)) {
+                hash.update(node_path_1.default.relative(root, file).split(node_path_1.default.sep).join('/'));
+                hash.update('\0');
+                hash.update(Uint8Array.from(node_fs_1.default.readFileSync(file)));
+                hash.update('\0');
+            }
+        }
+    };
+    visit(root);
+    return hash.digest('hex');
+}
+function createNativeModuleContracts(modules) {
+    return modules.map((module) => {
+        const files = [...module.rnoh.harPaths, ...(module.arkTs ? [module.arkTs.harPath] : [])]
+            .map(file => node_path_1.default.resolve(module.packageRoot, file));
+        let artifacts;
+        try {
+            artifacts = [...new Set(files.map(digest))];
+            if (module.source === 'nativeModulesDir')
+                artifacts.push(sourceDigest(node_path_1.default.join(module.packageRoot, 'harmony')));
+            artifacts.sort();
+        }
+        catch (cause) {
+            throw new errors_1.HarmonyAutolinkingError('RUNTIME_ARTIFACT', `Build the native HAR for ${module.packageName} before publishing or requesting its runtime contract.`, { cause, packageName: module.packageName, stage: 'runtime-contract' });
+        }
+        const registrations = [
+            ...module.expo.rootViewComponents.map(name => `view:${name}`),
+            ...module.expo.appLifecycleSubscribers.map(name => `app:${name}`),
+            ...module.expo.abilityLifecycleSubscribers.map(name => `ability:${name}`),
+            ...module.expo.reactNativeHostHandlers.map(name => `host:${name}`),
+            ...module.expo.reactActivityHandlers.map(name => `activity:${name}`),
+            ...module.expo.runtimeBindings.map(name => `binding:${name}`),
+            ...['etsPackageClassName', 'etsPackageImport', 'cppPackageClassName', 'cmakeLibraryTargetName']
+                .flatMap(field => module.rnoh[field] ? [`${field}:${module.rnoh[field]}`] : []),
+        ];
+        return {
+            packageName: module.packageName,
+            packageVersion: module.packageVersion,
+            modules: [...module.harmony.modules].sort(),
+            services: [...module.harmony.services].sort(),
+            registrations: registrations.sort(),
+            artifacts,
+        };
+    }).sort((left, right) => left.packageName < right.packageName ? -1 : left.packageName > right.packageName ? 1 : 0);
+}