expo-harmony-toolkit 1.8.1 → 1.8.2

package/README.en.md

@@ -9,7 +9,7 @@
   <p>
     <a href="https://github.com/BlackishGreen33/Expo-Harmony-Toolkit/actions/workflows/ci.yml"><img alt="Checks" src="https://img.shields.io/badge/checks-passing-16a34a?style=flat-square&logo=githubactions&logoColor=white"></a>
     <a href="./LICENSE"><img alt="License" src="https://img.shields.io/badge/license-MIT-0f766e?style=flat-square"></a>
-    <a href="https://github.com/BlackishGreen33/Expo-Harmony-Toolkit/releases"><img alt="Version" src="https://img.shields.io/badge/version-v1.8.1-111827?style=flat-square"></a>
+    <a href="https://github.com/BlackishGreen33/Expo-Harmony-Toolkit/releases"><img alt="Version" src="https://img.shields.io/badge/version-v1.8.2-111827?style=flat-square"></a>
     <a href="./docs/support-matrix.md"><img alt="Matrix" src="https://img.shields.io/badge/matrix-expo55--rnoh082--ui--stack-2563eb?style=flat-square"></a>
     <img alt="Input" src="https://img.shields.io/badge/input-Managed%2FCNG-059669?style=flat-square">
   </p>
@@ -48,7 +48,7 @@
 <!-- GENERATED:readme-current-status:start -->
 | Item | Status |
 | --- | --- |
-| Current version | `v1.8.1` |
+| Current version | `v1.8.2` |
 | Support model | `verified + preview + experimental` |
 | Public `verified` matrix | `expo55-rnoh082-ui-stack` |
 | Supported input | Managed/CNG Expo projects |
@@ -261,6 +261,7 @@ Additional preview evidence semantics:
 - `bundle/debugBuild` are marked as `automated`
 - `device` is marked as `manual-doc`, which means a human acceptance record exists rather than CI automation
 - `release` is marked as `none`, which means no release evidence exists yet
+- `v1.8.2` additionally records local signing plus simulator install/start evidence for the ccnubox release HAP; this only proves the minimal app-shell release-HAP path and does not close per-capability release acceptance
 
 Manual Harmony acceptance still requires:
 

package/README.md

@@ -9,7 +9,7 @@
   <p>
     <a href="https://github.com/BlackishGreen33/Expo-Harmony-Toolkit/actions/workflows/ci.yml"><img alt="Checks" src="https://img.shields.io/badge/checks-passing-16a34a?style=flat-square&logo=githubactions&logoColor=white"></a>
     <a href="./LICENSE"><img alt="License" src="https://img.shields.io/badge/license-MIT-0f766e?style=flat-square"></a>
-    <a href="https://github.com/BlackishGreen33/Expo-Harmony-Toolkit/releases"><img alt="Version" src="https://img.shields.io/badge/version-v1.8.1-111827?style=flat-square"></a>
+    <a href="https://github.com/BlackishGreen33/Expo-Harmony-Toolkit/releases"><img alt="Version" src="https://img.shields.io/badge/version-v1.8.2-111827?style=flat-square"></a>
     <a href="./docs/support-matrix.md"><img alt="Matrix" src="https://img.shields.io/badge/matrix-expo55--rnoh082--ui--stack-2563eb?style=flat-square"></a>
     <img alt="Input" src="https://img.shields.io/badge/input-Managed%2FCNG-059669?style=flat-square">
   </p>
@@ -48,7 +48,7 @@
 <!-- GENERATED:readme-current-status:start -->
 | 项目 | 说明 |
 | --- | --- |
-| 当前版本 | `v1.8.1` |
+| 当前版本 | `v1.8.2` |
 | 支持模型 | `verified + preview + experimental` |
 | 唯一 `verified` 公开矩阵 | `expo55-rnoh082-ui-stack` |
 | 输入范围 | Managed/CNG Expo 项目 |
@@ -267,6 +267,7 @@ preview 证据的额外说明：
 - `bundle/debugBuild` 标记为 `automated`
 - `device` 标记为 `manual-doc`，表示已有人工验收记录，不等于 CI 自动验收
 - `release` 标记为 `none`，表示当前仍没有 release 证据
+- `v1.8.2` 额外记录了 ccnubox release HAP 的本地签名、模拟器安装与启动证据；这只证明 app-shell release HAP 最低链路，不关闭单 capability release acceptance
 
 手动 Harmony 验收继续要求：
 

package/build/core/autolinking.js

@@ -17,21 +17,24 @@ exports.AUTOLINKED_FILE_PATHS = [
     path_1.default.join('harmony', 'entry', 'src', 'main', 'cpp', 'RNOHPackagesFactory.h'),
     path_1.default.join('harmony', 'entry', 'src', 'main', 'cpp', 'autolinking.cmake'),
 ];
-const HARMONY_PACKAGE_JSON_NORMALIZERS = {
-    '@react-native-oh-tpl/react-native-gesture-handler': (packageJson) => {
-        const harmony = packageJson.harmony && typeof packageJson.harmony === 'object' && !Array.isArray(packageJson.harmony)
-            ? { ...packageJson.harmony }
-            : null;
-        if (!harmony || !('codegenConfig' in harmony)) {
-            return null;
-        }
-        delete harmony.codegenConfig;
-        return {
-            ...packageJson,
-            harmony,
-        };
-    },
+const stripHarmonyCodegenConfig = (packageJson) => {
+    const harmony = packageJson.harmony && typeof packageJson.harmony === 'object' && !Array.isArray(packageJson.harmony)
+        ? { ...packageJson.harmony }
+        : null;
+    if (!harmony || !('codegenConfig' in harmony)) {
+        return null;
+    }
+    delete harmony.codegenConfig;
+    return {
+        ...packageJson,
+        harmony,
+    };
 };
+const ADAPTERS_REQUIRING_RNOH_CODEGEN = new Set([
+    '@react-native-oh-tpl/camera-roll',
+    '@react-native-oh-tpl/react-native-fs',
+]);
+const HARMONY_PACKAGE_JSON_NORMALIZERS = Object.fromEntries(uiStack_1.HARMONY_NATIVE_ADAPTERS.filter((adapter) => !ADAPTERS_REQUIRING_RNOH_CODEGEN.has(adapter.adapterPackageName)).map((adapter) => [adapter.adapterPackageName, stripHarmonyCodegenConfig]));
 class AutolinkingFailureError extends Error {
     constructor(stage, command, options = {}) {
         const details = [
@@ -100,6 +103,7 @@ async function normalizeKnownHarmonyPackageJsons(projectRoot) {
 async function generateAutolinkingArtifacts(projectRoot, harmonyRootPackageContents) {
     const rnohCliPackageJsonPath = resolveProjectPackageJson(projectRoot, '@react-native-oh/react-native-harmony-cli');
     const managedOhPackageContents = await buildManagedHarmonyRootPackageContents(projectRoot, harmonyRootPackageContents);
+    const installedHarmonyAdapters = await resolveInstalledHarmonyAdapters(projectRoot);
     const managedAutolinkingEntries = await resolveManagedAutolinkingEntries(projectRoot);
     if (!rnohCliPackageJsonPath) {
         return createEmptyAutolinkingArtifacts(managedOhPackageContents, managedAutolinkingEntries);
@@ -113,7 +117,9 @@ async function generateAutolinkingArtifacts(projectRoot, harmonyRootPackageConte
             await fs_extra_1.default.ensureDir(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'ets'));
             await fs_extra_1.default.ensureDir(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'cpp'));
             await fs_extra_1.default.writeFile(path_1.default.join(temporaryHarmonyRoot, 'oh-package.json5'), harmonyRootPackageContents);
-            await runRnohLinkHarmonyCommand(projectRoot, rnohCliPackageJsonPath, temporaryHarmonyRoot, commandDescription);
+            await runRnohLinkHarmonyCommand(projectRoot, rnohCliPackageJsonPath, temporaryHarmonyRoot, commandDescription, installedHarmonyAdapters
+                .filter(({ adapter }) => adapter.supportsAutolinking)
+                .map(({ adapter }) => adapter.adapterPackageName));
             await assertGeneratedAutolinkingFilesExist(temporaryHarmonyRoot, commandDescription);
             let normalizedEtsFactoryContents;
             let normalizedCppFactoryContents;
@@ -144,17 +150,17 @@ async function generateAutolinkingArtifacts(projectRoot, harmonyRootPackageConte
     }
 }
 async function resolveManagedAutolinkingEntries(projectRoot) {
-    const entries = await Promise.all(uiStack_1.UI_STACK_VALIDATED_ADAPTERS.map(async (adapter) => {
-        if (adapter.supportsAutolinking || !adapter.managedAutolinking) {
+    const entries = await Promise.all(uiStack_1.HARMONY_NATIVE_ADAPTERS.map(async (adapter) => {
+        if (!hasManagedAutolinking(adapter)) {
             return null;
         }
-        const dependencySpecifier = await resolveHarmonyAdapterHarDependency(projectRoot, adapter.adapterPackageName);
+        const dependencySpecifier = await resolveHarmonyAdapterHarDependency(projectRoot, adapter);
         if (!dependencySpecifier) {
             return null;
         }
         return {
-            adapterPackageName: adapter.adapterPackageName,
             ...adapter.managedAutolinking,
+            adapterPackageName: adapter.adapterPackageName,
         };
     }));
     return entries.filter((entry) => entry !== null);
@@ -179,25 +185,28 @@ async function normalizeAutolinkingEtsFactoryContents(projectRoot, contents) {
     let gestureHandlerPackageImportName = null;
     normalizedContents = normalizedContents.replace(/import\s+([A-Za-z_$][\w$]*)\s+from ['"]@react-native-oh-tpl\/react-native-gesture-handler['"];?/, (_match, importName) => {
         gestureHandlerPackageImportName = importName;
-        return "import { GestureHandlerPackage } from '@react-native-oh-tpl/react-native-gesture-handler/ts';";
+        return "import RnohReactNativeHarmonyGestureHandlerPackage from '@react-native-oh-tpl/react-native-gesture-handler';";
     });
     if (!gestureHandlerPackageImportName) {
         return normalizedContents;
     }
-    return normalizedContents.replace(new RegExp(`new\\s+${escapeRegExp(gestureHandlerPackageImportName)}\\(ctx\\)`, 'g'), 'new GestureHandlerPackage(ctx)');
+    return normalizedContents.replace(new RegExp(`new\\s+${escapeRegExp(gestureHandlerPackageImportName)}\\(ctx\\)`, 'g'), 'new RnohReactNativeHarmonyGestureHandlerPackage(ctx)');
 }
 function injectManagedAutolinkingIntoEtsFactory(contents, entries) {
     if (entries.length === 0) {
         return contents;
     }
     const missingImports = entries
-        .filter((entry) => !contents.includes(`from '${entry.etsImportPath}'`))
+        .filter((entry) => entry.etsImportPath &&
+        entry.etsPackageName &&
+        !contents.includes(`from '${entry.etsImportPath}'`))
         .map((entry) => `import { ${entry.etsPackageName} } from '${entry.etsImportPath}';`);
     if (missingImports.length > 0) {
         contents = contents.replace("import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';", `import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';\n${missingImports.join('\n')}`);
     }
     const missingFactoryEntries = entries
-        .filter((entry) => !contents.includes(`new ${entry.etsPackageName}(ctx)`))
+        .filter((entry) => entry.etsPackageName &&
+        !contents.includes(`new ${entry.etsPackageName}(ctx)`))
         .map((entry) => `    new ${entry.etsPackageName}(ctx),`);
     if (missingFactoryEntries.length > 0) {
         contents = contents.replace(/return \[\n/, `return [\n${missingFactoryEntries.join('\n')}\n`);
@@ -220,20 +229,25 @@ async function normalizeAutolinkingCppFactoryContents(projectRoot, contents) {
     }
     return contents
         .replace(/#include "ReactNativeOhTplReactNativeGestureHandlerPackage\.h"/, '#include "RnohReactNativeHarmonyGestureHandlerPackage.h"')
-        .replace(/\brnoh::ReactNativeOhTplReactNativeGestureHandlerPackage\b/g, 'rnoh::RnohReactNativeHarmonyGestureHandlerPackage');
+        .replace(/\brnoh::ReactNativeOhTplReactNativeGestureHandlerPackage\b/g, 'rnoh::RnohReactNativeHarmonyGestureHandlerPackage')
+        .replace(/#include "ReactNativeOhTplReactNativeScreensPackage\.h"/, '#include "ScreensPackage.h"')
+        .replace(/std::make_shared<rnoh::ReactNativeOhTplReactNativeScreensPackage>\(ctx\)/g, 'std::make_shared<ScreensPackage>(ctx)');
 }
 function injectManagedAutolinkingIntoCppFactory(contents, entries) {
     if (entries.length === 0) {
         return contents;
     }
     const missingIncludes = entries
-        .filter((entry) => !contents.includes(`#include "${entry.cppHeaderName}"`))
+        .filter((entry) => entry.cppHeaderName &&
+        entry.cppPackageName &&
+        !contents.includes(`#include "${entry.cppHeaderName}"`))
         .map((entry) => `#include "${entry.cppHeaderName}"`);
     if (missingIncludes.length > 0) {
         contents = contents.replace('#include "RNOH/Package.h"', `#include "RNOH/Package.h"\n${missingIncludes.join('\n')}`);
     }
     const missingFactoryEntries = entries
-        .filter((entry) => !contents.includes(`std::make_shared<rnoh::${entry.cppPackageName}>(ctx)`))
+        .filter((entry) => entry.cppPackageName &&
+        !contents.includes(`std::make_shared<rnoh::${entry.cppPackageName}>(ctx)`))
         .map((entry) => `    std::make_shared<rnoh::${entry.cppPackageName}>(ctx),`);
     if (missingFactoryEntries.length > 0) {
         contents = contents.replace(/return \{\n/, `return {\n${missingFactoryEntries.join('\n')}\n`);
@@ -245,20 +259,22 @@ function injectManagedAutolinkingIntoCmake(contents, entries) {
         return contents;
     }
     const missingSubdirectories = entries
-        .filter((entry) => !contents.includes(`./${entry.cmakeTargetName}`))
+        .filter((entry) => entry.cmakeTargetName &&
+        !contents.includes(`./${entry.cmakeTargetName}`))
         .map((entry) => `    add_subdirectory("\${OH_MODULES_DIR}/${entry.adapterPackageName}/src/main/cpp" ./${entry.cmakeTargetName})`);
     if (missingSubdirectories.length > 0) {
         contents = contents.replace(/function\(autolink_libraries target\)\n/, `function(autolink_libraries target)\n${missingSubdirectories.join('\n')}\n`);
     }
     const missingLibraryTargets = entries
-        .filter((entry) => !contents.includes(`        ${entry.cmakeTargetName}`))
+        .filter((entry) => entry.cmakeTargetName &&
+        !contents.includes(`        ${entry.cmakeTargetName}`))
         .map((entry) => `        ${entry.cmakeTargetName}`);
     if (missingLibraryTargets.length > 0) {
         contents = contents.replace(/set\(AUTOLINKED_LIBRARIES\n/, `set(AUTOLINKED_LIBRARIES\n${missingLibraryTargets.join('\n')}\n`);
     }
     return contents;
 }
-async function runRnohLinkHarmonyCommand(projectRoot, rnohCliPackageJsonPath, harmonyProjectPath, commandDescription) {
+async function runRnohLinkHarmonyCommand(projectRoot, rnohCliPackageJsonPath, harmonyProjectPath, commandDescription, includeNpmPackages) {
     const rnohCliRoot = path_1.default.dirname(rnohCliPackageJsonPath);
     let commandLinkHarmony;
     try {
@@ -277,7 +293,7 @@ async function runRnohLinkHarmonyCommand(projectRoot, rnohCliPackageJsonPath, ha
             cppRnohPackagesFactoryPathRelativeToHarmony: './entry/src/main/cpp/RNOHPackagesFactory.h',
             etsRnohPackagesFactoryPathRelativeToHarmony: './entry/src/main/ets/RNOHPackagesFactory.ets',
             ohPackagePathRelativeToHarmony: './oh-package.json5',
-            includeNpmPackages: uiStack_1.UI_STACK_ADAPTER_PACKAGE_NAMES,
+            includeNpmPackages,
         });
     }
     catch (error) {
@@ -316,11 +332,8 @@ async function buildManagedHarmonyRootPackageContents(projectRoot, harmonyRootPa
         ...(parsedPackageJson.dependencies ?? {}),
         ...(await readPreservedHarmonyRootDependencies(projectRoot)),
     };
-    for (const adapter of uiStack_1.UI_STACK_VALIDATED_ADAPTERS) {
-        const dependencySpecifier = await resolveHarmonyAdapterHarDependency(projectRoot, adapter.adapterPackageName);
-        if (dependencySpecifier) {
-            dependencies[adapter.adapterPackageName] = dependencySpecifier;
-        }
+    for (const { adapter, dependencySpecifier } of await resolveInstalledHarmonyAdapters(projectRoot)) {
+        dependencies[adapter.adapterPackageName] = dependencySpecifier;
     }
     parsedPackageJson.dependencies = sortRecordByKey(dependencies);
     return json5_1.default.stringify(parsedPackageJson, null, 2) + '\n';
@@ -332,31 +345,40 @@ async function readPreservedHarmonyRootDependencies(projectRoot) {
     }
     const currentHarmonyRootPackage = json5_1.default.parse(await fs_extra_1.default.readFile(harmonyRootPackagePath, 'utf8'));
     const preservedDependencies = {};
-    const validatedAdapterPackageNames = new Set(uiStack_1.UI_STACK_ADAPTER_PACKAGE_NAMES);
+    const managedAdapterPackageNames = new Set(uiStack_1.HARMONY_NATIVE_ADAPTER_PACKAGE_NAMES);
     for (const [packageName, specifier] of Object.entries(currentHarmonyRootPackage.dependencies ?? {})) {
         if (typeof specifier !== 'string') {
             continue;
         }
-        if (validatedAdapterPackageNames.has(packageName)) {
+        if (managedAdapterPackageNames.has(packageName)) {
             continue;
         }
         preservedDependencies[packageName] = specifier;
     }
     return preservedDependencies;
 }
-async function resolveHarmonyAdapterHarDependency(projectRoot, adapterPackageName) {
-    const adapterEntry = uiStack_1.UI_STACK_VALIDATED_ADAPTERS.find((candidate) => candidate.adapterPackageName === adapterPackageName);
-    if (!adapterEntry) {
-        return null;
-    }
-    const adapterRoot = path_1.default.join(projectRoot, 'node_modules', ...adapterPackageName.split('/'));
-    const harPath = path_1.default.join(adapterRoot, 'harmony', adapterEntry.harmonyHarFileName);
+async function resolveHarmonyAdapterHarDependency(projectRoot, adapter) {
+    const adapterRoot = path_1.default.join(projectRoot, 'node_modules', ...adapter.adapterPackageName.split('/'));
+    const harPath = path_1.default.join(adapterRoot, 'harmony', adapter.harmonyHarFileName);
     if (!(await fs_extra_1.default.pathExists(harPath))) {
         return null;
     }
     const relativeHarPath = path_1.default.relative(path_1.default.join(projectRoot, 'harmony'), harPath).replace(/\\/g, '/');
     return `file:${relativeHarPath}`;
 }
+async function resolveInstalledHarmonyAdapters(projectRoot) {
+    const entries = [];
+    for (const adapter of uiStack_1.HARMONY_NATIVE_ADAPTERS) {
+        const dependencySpecifier = await resolveHarmonyAdapterHarDependency(projectRoot, adapter);
+        if (dependencySpecifier) {
+            entries.push({ adapter, dependencySpecifier });
+        }
+    }
+    return entries;
+}
+function hasManagedAutolinking(adapter) {
+    return 'managedAutolinking' in adapter && Boolean(adapter.managedAutolinking);
+}
 function createEmptyAutolinkingArtifacts(harmonyRootPackageContents, managedAutolinkingEntries) {
     return {
         ohPackageContents: harmonyRootPackageContents,

package/build/core/build/compatibilityShims.js

@@ -188,10 +188,19 @@ function createGestureHandlerCompatibilityDescriptorHeader(componentName) {
     ].join('\n');
 }
 function patchGestureHandlerCompatibilityPackageHeader(contents) {
-    if (contents.includes('createComponentDescriptorProviders() override;')) {
-        return contents;
+    let nextContents = contents;
+    if (!nextContents.includes('createTurboModuleFactoryDelegate() override;')) {
+        nextContents = nextContents.replace(/    EventEmitRequestHandlers createEventEmitRequestHandlers\(\);\r?\n/, [
+            '    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override;',
+            '',
+            '    EventEmitRequestHandlers createEventEmitRequestHandlers();',
+            '',
+        ].join('\n'));
+    }
+    if (nextContents.includes('createComponentDescriptorProviders() override;')) {
+        return nextContents;
     }
-    return contents.replace('    std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;\n', [
+    return nextContents.replace(/    std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers\(\) override;\r?\n/, [
         '    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override;',
         '',
         '    ComponentJSIBinderByString createComponentJSIBinderByName() override;',
@@ -202,13 +211,16 @@ function patchGestureHandlerCompatibilityPackageHeader(contents) {
 function patchGestureHandlerCompatibilityPackageSource(contents) {
     let nextContents = contents;
     if (!nextContents.includes('#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"')) {
-        nextContents = nextContents.replace('#include "RNOH/RNInstanceCAPI.h"\n', '#include "RNOH/RNInstanceCAPI.h"\n#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"\n');
+        nextContents = nextContents.replace(/#include "RNOH\/RNInstanceCAPI\.h"\r?\n/, '#include "RNOH/RNInstanceCAPI.h"\n#include "RNOH/ArkTSTurboModule.h"\n#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"\n');
+    }
+    else if (!nextContents.includes('#include "RNOH/ArkTSTurboModule.h"')) {
+        nextContents = nextContents.replace(/#include "RNOH\/RNInstanceCAPI\.h"\r?\n/, '#include "RNOH/RNInstanceCAPI.h"\n#include "RNOH/ArkTSTurboModule.h"\n');
     }
     if (!nextContents.includes('#include "generated/RNGestureHandlerButtonComponentDescriptor.h"')) {
-        nextContents = nextContents.replace('#include "componentInstances/RNGestureHandlerRootViewComponentInstance.h"\n', '#include "componentInstances/RNGestureHandlerRootViewComponentInstance.h"\n#include "generated/RNGestureHandlerButtonComponentDescriptor.h"\n#include "generated/RNGestureHandlerRootViewComponentDescriptor.h"\n');
+        nextContents = nextContents.replace(/#include "componentInstances\/RNGestureHandlerRootViewComponentInstance\.h"\r?\n/, '#include "componentInstances/RNGestureHandlerRootViewComponentInstance.h"\n#include "generated/RNGestureHandlerButtonComponentDescriptor.h"\n#include "generated/RNGestureHandlerRootViewComponentDescriptor.h"\n');
     }
     if (!nextContents.includes('class RNGestureHandlerComponentJSIBinder')) {
-        nextContents = nextContents.replace('using namespace rnoh;\nusing namespace facebook;\n\n', [
+        nextContents = nextContents.replace(/using namespace rnoh;\r?\nusing namespace facebook;\r?\n\r?\n/, [
             'using namespace rnoh;',
             'using namespace facebook;',
             '',
@@ -244,8 +256,52 @@ function patchGestureHandlerCompatibilityPackageSource(contents) {
             '',
         ].join('\n'));
     }
+    if (!nextContents.includes('class RNGestureHandlerTurboModule : public ArkTSTurboModule')) {
+        nextContents = nextContents.replace(/using namespace rnoh;\r?\nusing namespace facebook;\r?\n\r?\n/, [
+            'using namespace rnoh;',
+            'using namespace facebook;',
+            '',
+            'class RNGestureHandlerTurboModule : public ArkTSTurboModule {',
+            'public:',
+            '    RNGestureHandlerTurboModule(const ArkTSTurboModule::Context ctx, const std::string name)',
+            '        : ArkTSTurboModule(ctx, name) {',
+            '        methodMap_ = {',
+            '            ARK_METHOD_METADATA(handleSetJSResponder, 2),',
+            '            ARK_METHOD_METADATA(handleClearJSResponder, 0),',
+            '            ARK_METHOD_METADATA(createGestureHandler, 3),',
+            '            ARK_METHOD_METADATA(attachGestureHandler, 3),',
+            '            ARK_METHOD_METADATA(updateGestureHandler, 2),',
+            '            ARK_METHOD_METADATA(dropGestureHandler, 1),',
+            '            ARK_METHOD_METADATA(install, 0),',
+            '            ARK_METHOD_METADATA(flushOperations, 0),',
+            '        };',
+            '    }',
+            '};',
+            '',
+            'class RNGestureHandlerTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {',
+            'public:',
+            '    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {',
+            '        if (name == "RNGestureHandlerModule") {',
+            '            return std::make_shared<RNGestureHandlerTurboModule>(ctx, name);',
+            '        }',
+            '        return nullptr;',
+            '    };',
+            '};',
+            '',
+        ].join('\n'));
+    }
+    if (!nextContents.includes('RnohReactNativeHarmonyGestureHandlerPackage::createTurboModuleFactoryDelegate()')) {
+        nextContents = nextContents.replace(/EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers\(\) \{\r?\n/, [
+            'std::unique_ptr<TurboModuleFactoryDelegate>',
+            'RnohReactNativeHarmonyGestureHandlerPackage::createTurboModuleFactoryDelegate() {',
+            '    return std::make_unique<RNGestureHandlerTurboModuleFactoryDelegate>();',
+            '}',
+            '',
+            'EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers() {\n',
+        ].join('\n'));
+    }
     if (!nextContents.includes('RnohReactNativeHarmonyGestureHandlerPackage::createComponentDescriptorProviders()')) {
-        nextContents = nextContents.replace('EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers() {\n', [
+        nextContents = nextContents.replace(/EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers\(\) \{\r?\n/, [
             'std::vector<facebook::react::ComponentDescriptorProvider>',
             'RnohReactNativeHarmonyGestureHandlerPackage::createComponentDescriptorProviders() {',
             '    return {',
@@ -265,7 +321,7 @@ function patchGestureHandlerCompatibilityPackageSource(contents) {
             '    };',
             '}',
             '',
-            'EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers() {',
+            'EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers() {\n',
         ].join('\n'));
     }
     return nextContents;

package/build/core/build/localHar.d.ts

@@ -9,5 +9,7 @@ export declare function normalizeLocalHarDependencies(harmonyProjectRoot: string
 }>;
 export declare function ensureHarmonyBuildProfileSupportsNormalizedLocalDeps(harmonyProjectRoot: string, localHarPackages: NormalizedLocalHarPackage[]): Promise<() => Promise<void>>;
 export declare function ensureRnohGeneratedTsShim(harmonyProjectRoot: string): Promise<void>;
+export declare function patchRnohGeneratedCodegenForNormalizedLocalPackage(harmonyProjectRoot: string): Promise<void>;
+export declare function patchKnownHarmonyAdapterCodegenOutputs(harmonyProjectRoot: string): Promise<void>;
 export declare function alignRnohCodegenWithNormalizedLocalPackage(harmonyProjectRoot: string, localHarPackages: NormalizedLocalHarPackage[]): Promise<() => Promise<void>>;
 export declare function findHarmonyArtifacts(harmonyProjectRoot: string): Promise<string[]>;

package/build/core/build/localHar.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeLocalHarDependencies = normalizeLocalHarDependencies;
 exports.ensureHarmonyBuildProfileSupportsNormalizedLocalDeps = ensureHarmonyBuildProfileSupportsNormalizedLocalDeps;
 exports.ensureRnohGeneratedTsShim = ensureRnohGeneratedTsShim;
+exports.patchRnohGeneratedCodegenForNormalizedLocalPackage = patchRnohGeneratedCodegenForNormalizedLocalPackage;
+exports.patchKnownHarmonyAdapterCodegenOutputs = patchKnownHarmonyAdapterCodegenOutputs;
 exports.alignRnohCodegenWithNormalizedLocalPackage = alignRnohCodegenWithNormalizedLocalPackage;
 exports.findHarmonyArtifacts = findHarmonyArtifacts;
 const node_child_process_1 = require("node:child_process");
@@ -273,6 +275,47 @@ async function ensureRnohGeneratedTsShim(harmonyProjectRoot) {
     await fs_extra_1.default.ensureDir(path_1.default.dirname(shimPath));
     await fs_extra_1.default.writeFile(shimPath, `export * from '${relativeTarget}';\n`);
 }
+async function patchRnohGeneratedCodegenForNormalizedLocalPackage(harmonyProjectRoot) {
+    const generatedRootPath = path_1.default.join(harmonyProjectRoot, 'expo-harmony-local-deps', 'rnoh-react-native-openharmony-react_native_openharmony', 'generated');
+    if (!(await fs_extra_1.default.pathExists(generatedRootPath))) {
+        return;
+    }
+    const generatedFilePaths = await listFilesRecursively(generatedRootPath);
+    await Promise.all(generatedFilePaths
+        .filter((filePath) => filePath.endsWith('.ts') || filePath.endsWith('.ets'))
+        .map(async (filePath) => {
+        const originalContents = await fs_extra_1.default.readFile(filePath, 'utf8');
+        let updatedContents = originalContents.replace(/from\s+['"]@rnoh\/react-native-openharmony\/ts['"]/g, () => {
+            let relativeTarget = path_1.default.relative(path_1.default.dirname(filePath), path_1.default.join(harmonyProjectRoot, 'expo-harmony-local-deps', 'rnoh-react-native-openharmony-react_native_openharmony', 'ts.ts'));
+            relativeTarget = relativeTarget.replace(/\\/g, '/').replace(/\.ts$/, '');
+            return `from '${relativeTarget.startsWith('.') ? relativeTarget : `./${relativeTarget}`}'`;
+        });
+        if (path_1.default.basename(filePath) === 'RNCCameraRoll.ts') {
+            updatedContents = updatedContents.replace(/getPhotoThumbnail\(internalID: string, options: Object\): Promise<void>;/, 'getPhotoThumbnail(internalID: string, options: Object): Promise<Object>;');
+        }
+        if (updatedContents !== originalContents) {
+            await fs_extra_1.default.writeFile(filePath, updatedContents);
+        }
+    }));
+}
+async function patchKnownHarmonyAdapterCodegenOutputs(harmonyProjectRoot) {
+    await patchSafeAreaContextGeneratedProps(harmonyProjectRoot);
+}
+async function patchSafeAreaContextGeneratedProps(harmonyProjectRoot) {
+    const propsHeaderPath = path_1.default.join(harmonyProjectRoot, 'oh_modules', '@react-native-oh-tpl', 'react-native-safe-area-context', 'src', 'main', 'cpp', 'generated', 'react', 'renderer', 'components', 'react_native_safe_area_context', 'Props.h');
+    if (!(await fs_extra_1.default.pathExists(propsHeaderPath))) {
+        return;
+    }
+    const originalContents = await fs_extra_1.default.readFile(propsHeaderPath, 'utf8');
+    let updatedContents = originalContents.replace(/\bbutter::map<std::string, RawValue>/g, 'std::unordered_map<std::string, RawValue>');
+    if (updatedContents !== originalContents &&
+        !updatedContents.includes('#include <unordered_map>')) {
+        updatedContents = updatedContents.replace('#include <react/renderer/components/view/ViewProps.h>', '#include <unordered_map>\n\n#include <react/renderer/components/view/ViewProps.h>');
+    }
+    if (updatedContents !== originalContents) {
+        await fs_extra_1.default.writeFile(propsHeaderPath, updatedContents);
+    }
+}
 async function alignRnohCodegenWithNormalizedLocalPackage(harmonyProjectRoot, localHarPackages) {
     const rnohPackage = localHarPackages.find((localPackage) => localPackage.packageName === '@rnoh/react-native-openharmony');
     if (!rnohPackage) {
@@ -312,6 +355,20 @@ async function alignRnohCodegenWithNormalizedLocalPackage(harmonyProjectRoot, lo
         await fs_extra_1.default.remove(backupRootPath);
     };
 }
+async function listFilesRecursively(rootPath) {
+    const entries = await fs_extra_1.default.readdir(rootPath, { withFileTypes: true });
+    const nestedEntries = await Promise.all(entries.map(async (entry) => {
+        const entryPath = path_1.default.join(rootPath, entry.name);
+        if (entry.isDirectory()) {
+            return listFilesRecursively(entryPath);
+        }
+        if (entry.isFile()) {
+            return [entryPath];
+        }
+        return [];
+    }));
+    return nestedEntries.flat();
+}
 async function findHarmonyArtifacts(harmonyProjectRoot) {
     const discoveredPaths = [];
     await walkDirectory(harmonyProjectRoot, async (entryPath) => {

package/build/core/build/rnohCompatibility.js

@@ -9,6 +9,12 @@ const path_1 = __importDefault(require("path"));
 const RNOH_CLI_AUTOLINKING_TEMPLATE_RELATIVE_PATHS = [
     path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'dist', 'autolinking', 'Autolinking.js'),
     path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'src', 'autolinking', 'Autolinking.ts'),
+    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'dist', 'commands', 'codegen-lib-harmony.js'),
+    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'src', 'commands', 'codegen-lib-harmony.ts'),
+    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'dist', 'codegen', 'generators', 'UberGeneratorV1.js'),
+    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'src', 'codegen', 'generators', 'UberGeneratorV1.ts'),
+    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'dist', 'codegen', 'templates', 'TurboModuleSpecTSTemplate.js'),
+    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'src', 'codegen', 'templates', 'TurboModuleSpecTSTemplate.ts'),
 ];
 async function normalizeProjectRnohCliAutolinkingTemplates(projectRoot) {
     const originalContentsByPath = new Map();
@@ -34,5 +40,32 @@ async function normalizeProjectRnohCliAutolinkingTemplates(projectRoot) {
 function normalizeRnohCliAutolinkingTemplateContents(contents) {
     return contents
         .replace(/import type \{ RNPackageContext, RNOHPackage \} from '@rnoh\/react-native-openharmony';/g, "import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';")
-        .replace(/export function createRNOHPackages\(ctx: RNPackageContext\): RNOHPackage\[\] \{/g, 'export function createRNOHPackages(ctx: RNPackageContext): RNPackage[] {');
+        .replace(/export function createRNOHPackages\(ctx: RNPackageContext\): RNOHPackage\[\] \{/g, 'export function createRNOHPackages(ctx: RNPackageContext): RNPackage[] {')
+        .replace(/(['"])@rnoh\/react-native-openharmony\/ts\1/g, "'../../ts'")
+        .replace(/  addMethod\(method: Method\) {\n    this\.methods\.push\(method\);\n  }/, `  addMethod(method: Method) {
+    if (method.name === 'getPhotoThumbnail' && method.returnType === 'Promise<void>') {
+      method = { ...method, returnType: 'Promise<Object>' };
+    }
+    this.methods.push(method);
+  }`)
+        .replace(/    addMethod\(method\) {\n        this\.methods\.push\(method\);\n    }/, `    addMethod(method) {
+        if (method.name === 'getPhotoThumbnail' && method.returnType === 'Promise<void>') {
+            method = { ...method, returnType: 'Promise<Object>' };
+        }
+        this.methods.push(method);
+    }`)
+        .replace('    const isRNOHModulePath = this.etsOutputPath.getValue().endsWith(`${RNOH_OHOS_NAME}/generated`.replace(/\\//g, pathUtils.sep));', `    const normalizedEtsOutputPath = this.etsOutputPath.getValue().replace(/\\\\/g, '/');
+    const isRNOHModulePath =
+      normalizedEtsOutputPath.endsWith(\`\${RNOH_OHOS_NAME}/generated\`) ||
+      normalizedEtsOutputPath.endsWith('rnoh-react-native-openharmony-react_native_openharmony/generated');`)
+        .replace('        const isRNOHModulePath = this.etsOutputPath.getValue().endsWith(`${RNOH_OHOS_NAME}/generated`.replace(/\\//g, path_1.default.sep));', `        const normalizedEtsOutputPath = this.etsOutputPath.getValue().replace(/\\\\/g, '/');
+        const isRNOHModulePath = normalizedEtsOutputPath.endsWith(\`\${RNOH_OHOS_NAME}/generated\`) ||
+            normalizedEtsOutputPath.endsWith('rnoh-react-native-openharmony-react_native_openharmony/generated');`)
+        .replace(/    const isRNOHModulePath = this\.etsOutputPath\.getValue\(\)\.endsWith\(`\$\{RNOH_OHOS_NAME\}\/generated`\.replace\(\/\\\/\/g, pathUtils\.sep\)\);/, `    const normalizedEtsOutputPath = this.etsOutputPath.getValue().replace(/\\\\/g, '/');
+    const isRNOHModulePath =
+      normalizedEtsOutputPath.endsWith(\`\${RNOH_OHOS_NAME}/generated\`) ||
+      normalizedEtsOutputPath.endsWith('rnoh-react-native-openharmony-react_native_openharmony/generated');`)
+        .replace(/        const isRNOHModulePath = this\.etsOutputPath\.getValue\(\)\.endsWith\(`\$\{RNOH_OHOS_NAME\}\/generated`\.replace\(\/\\\/\/g, path_1\.default\.sep\)\);/, `        const normalizedEtsOutputPath = this.etsOutputPath.getValue().replace(/\\\\/g, '/');
+        const isRNOHModulePath = normalizedEtsOutputPath.endsWith(\`\${RNOH_OHOS_NAME}/generated\`) ||
+            normalizedEtsOutputPath.endsWith('rnoh-react-native-openharmony-react_native_openharmony/generated');`);
 }

package/build/core/build.js

@@ -352,6 +352,8 @@ async function buildHapProject(projectRoot, options) {
         if (!normalizedLocalHarPackages.some((localPackage) => localPackage.packageName === '@rnoh/react-native-openharmony')) {
             await (0, localHar_1.ensureRnohGeneratedTsShim)(harmonyProjectRoot);
         }
+        await (0, localHar_1.patchRnohGeneratedCodegenForNormalizedLocalPackage)(harmonyProjectRoot);
+        await (0, localHar_1.patchKnownHarmonyAdapterCodegenOutputs)(harmonyProjectRoot);
         const hvigorCommand = (0, commands_1.buildInvocation)(envReport.hvigorPath, [
             'assembleHap',
             '--no-daemon',

package/build/core/constants.d.ts

@@ -1,6 +1,6 @@
 export declare const TOOLKIT_PACKAGE_NAME = "expo-harmony-toolkit";
 export declare const CLI_NAME = "expo-harmony";
-export declare const TOOLKIT_VERSION = "1.8.1";
+export declare const TOOLKIT_VERSION = "1.8.2";
 export declare const TEMPLATE_VERSION = "rnoh-0.82.18";
 export declare const RNOH_VERSION = "0.82.18";
 export declare const RNOH_CLI_VERSION = "0.82.18";

package/build/core/constants.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DESIRED_PACKAGE_SCRIPTS = exports.HARMONY_RUNTIME_PRELUDE_RELATIVE_PATH = exports.HARMONY_ROUTER_ENTRY_FILENAME = exports.STRICT_ENV_EXIT_CODE = exports.STRICT_DOCTOR_EXIT_CODE = exports.DEFAULT_HVIGOR_PLUGIN_FILENAME = exports.PREBUILD_METADATA_FILENAME = exports.TOOLKIT_CONFIG_FILENAME = exports.BUILD_REPORT_FILENAME = exports.ENV_REPORT_FILENAME = exports.DOCTOR_REPORT_FILENAME = exports.MANIFEST_FILENAME = exports.SIGNING_LOCAL_EXAMPLE_FILENAME = exports.SIGNING_LOCAL_FILENAME = exports.GENERATED_SHIMS_DIR = exports.GENERATED_DIR = exports.SUPPORTED_EXPO_SDKS = exports.RNOH_CLI_VERSION = exports.RNOH_VERSION = exports.TEMPLATE_VERSION = exports.TOOLKIT_VERSION = exports.CLI_NAME = exports.TOOLKIT_PACKAGE_NAME = void 0;
 exports.TOOLKIT_PACKAGE_NAME = 'expo-harmony-toolkit';
 exports.CLI_NAME = 'expo-harmony';
-exports.TOOLKIT_VERSION = '1.8.1';
+exports.TOOLKIT_VERSION = '1.8.2';
 exports.TEMPLATE_VERSION = 'rnoh-0.82.18';
 exports.RNOH_VERSION = '0.82.18';
 exports.RNOH_CLI_VERSION = '0.82.18';

package/build/core/report.js

@@ -254,9 +254,17 @@ async function collectBlockingIssues(projectRoot, expoConfig, packageJson, expoP
                 subject: dependencyName,
             });
         }
+        if (rule.specifiers &&
+            !rule.specifiers.some((specifier) => matchesDependencySpecifier(dependency.version, specifier))) {
+            issues.push({
+                code: 'dependency.specifier_mismatch',
+                message: `Dependency ${dependencyName} does not match any validated dependency spec: ${rule.specifiers.join(', ')}.`,
+                subject: dependencyName,
+            });
+        }
     }
     for (const dependency of dependencies) {
-        if (!isDependencyAllowedForTargetTier(dependency.name, matrix, targetTier)) {
+        if (shouldBlockDependencyForTargetTier(dependency, matrix, targetTier)) {
             issues.push({
                 code: 'dependency.not_allowed',
                 message: `${dependency.name} is outside the ${targetTier} support tier for ${matrix.id}.`,
@@ -526,6 +534,15 @@ function isDependencyAllowedForTargetTier(dependencyName, matrix, targetTier) {
     const capability = capabilities_1.CAPABILITY_BY_PACKAGE[dependencyName];
     return capability ? (0, capabilities_1.isSupportTierAllowed)(capability.supportTier, targetTier) : false;
 }
+function shouldBlockDependencyForTargetTier(dependency, matrix, targetTier) {
+    if (dependency.source === 'devDependency') {
+        return false;
+    }
+    if (dependency.buildabilityRisk === 'js-only-unknown') {
+        return false;
+    }
+    return !isDependencyAllowedForTargetTier(dependency.name, matrix, targetTier);
+}
 function matchesVersionRange(rawVersion, range) {
     const coerced = semver_1.default.coerce(rawVersion);
     if (!coerced) {

package/build/data/capabilities.js

@@ -155,5 +155,7 @@ function getCapabilityDefinitionsForProject(packageJson, options = {}) {
         (0, project_1.hasDeclaredDependency)(packageJson, definition.packageName)).sort((left, right) => left.packageName.localeCompare(right.packageName));
 }
 function collectCapabilityHarmonyPermissions(packageJson, options = {}) {
-    return Array.from(new Set(getCapabilityDefinitionsForProject(packageJson, options).flatMap((definition) => definition.harmonyPermissions))).sort((left, right) => left.localeCompare(right));
+    return Array.from(new Set(getCapabilityDefinitionsForProject(packageJson, options)
+        .filter((definition) => definition.runtimeMode !== 'shim')
+        .flatMap((definition) => definition.harmonyPermissions))).sort((left, right) => left.localeCompare(right));
 }