expo-harmony-toolkit 1.8.0 → 1.8.2

package/build/core/project.js

@@ -10,6 +10,8 @@ exports.findAppConfigPath = findAppConfigPath;
 exports.collectDeclaredDependencies = collectDeclaredDependencies;
 exports.hasDeclaredDependency = hasDeclaredDependency;
 exports.collectExpoPlugins = collectExpoPlugins;
+exports.resolveExpoHarmonyDoctorConfig = resolveExpoHarmonyDoctorConfig;
+exports.applyDependencyExclusions = applyDependencyExclusions;
 exports.collectExpoSchemes = collectExpoSchemes;
 exports.deriveHarmonyIdentifiers = deriveHarmonyIdentifiers;
 exports.detectExpoSdkVersion = detectExpoSdkVersion;
@@ -100,6 +102,27 @@ function collectExpoPlugins(expoConfig) {
     }
     return [...names].sort((left, right) => left.localeCompare(right));
 }
+function resolveExpoHarmonyDoctorConfig(expoConfig) {
+    const rawDoctorConfig = expoConfig.extra?.expoHarmony?.doctor;
+    const coverageProfile = normalizeCoverageProfile(rawDoctorConfig?.coverageProfile);
+    return {
+        excludeDependencies: normalizeStringArray(rawDoctorConfig?.excludeDependencies),
+        excludePlugins: normalizeStringArray(rawDoctorConfig?.excludePlugins),
+        coverageProfile,
+    };
+}
+function applyDependencyExclusions(packageJson, excludedDependencies) {
+    if (excludedDependencies.length === 0) {
+        return packageJson;
+    }
+    const excludedDependencySet = new Set(excludedDependencies);
+    return {
+        ...packageJson,
+        dependencies: filterDependencySection(packageJson.dependencies, excludedDependencySet),
+        devDependencies: filterDependencySection(packageJson.devDependencies, excludedDependencySet),
+        peerDependencies: filterDependencySection(packageJson.peerDependencies, excludedDependencySet),
+    };
+}
 function collectExpoSchemes(expoConfig) {
     const rawScheme = expoConfig.scheme;
     if (typeof rawScheme === 'string' && rawScheme.trim().length > 0) {
@@ -204,3 +227,27 @@ function sanitizeIdentifierSegment(value) {
         .replace(/^_+/, '');
     return cleaned.length > 0 ? cleaned : 'entry';
 }
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return [...new Set(value
+            .filter((entry) => typeof entry === 'string')
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function normalizeCoverageProfile(value) {
+    if (value === 'managed-core' ||
+        value === 'managed-native-heavy' ||
+        value === 'bare' ||
+        value === 'third-party-native-heavy') {
+        return value;
+    }
+    return null;
+}
+function filterDependencySection(section, excludedDependencies) {
+    if (!section) {
+        return section;
+    }
+    return Object.fromEntries(Object.entries(section).filter(([dependencyName]) => !excludedDependencies.has(dependencyName)));
+}

package/build/core/report.js

@@ -27,13 +27,16 @@ const BARE_WORKFLOW_DIRECTORY_NAMES = ['android', 'ios'];
 const BARE_WORKFLOW_DEPENDENCIES = new Set(['expo-build-properties', 'expo-dev-client']);
 async function buildDoctorReport(projectRoot, options = {}) {
     const loadedProject = await (0, project_1.loadProject)(projectRoot);
+    const doctorConfig = (0, project_1.resolveExpoHarmonyDoctorConfig)(loadedProject.expoConfig);
+    const filteredPackageJson = (0, project_1.applyDependencyExclusions)(loadedProject.packageJson, doctorConfig.excludeDependencies);
     const expoSdkVersion = (0, project_1.detectExpoSdkVersion)(loadedProject.packageJson);
     const matrix = validatedMatrices_1.VALIDATED_RELEASE_MATRICES[validatedMatrices_1.DEFAULT_VALIDATED_MATRIX_ID];
     const targetTier = options.targetTier ?? 'verified';
-    const expoPlugins = (0, project_1.collectExpoPlugins)(loadedProject.expoConfig);
+    const excludedPlugins = new Set(doctorConfig.excludePlugins);
+    const expoPlugins = (0, project_1.collectExpoPlugins)(loadedProject.expoConfig).filter((pluginName) => !excludedPlugins.has(pluginName));
     const expoSchemes = (0, project_1.collectExpoSchemes)(loadedProject.expoConfig);
     const dependencyRecords = new Map();
-    const declaredDependencies = (0, project_1.collectDeclaredDependencies)(loadedProject.packageJson);
+    const declaredDependencies = (0, project_1.collectDeclaredDependencies)(filteredPackageJson);
     for (const dependency of declaredDependencies) {
         dependencyRecords.set(dependency.name, createDependencyRecord(dependency.name, dependency.version, dependency.source));
     }
@@ -43,8 +46,11 @@ async function buildDoctorReport(projectRoot, options = {}) {
         }
     }
     const dependencies = await (0, dependencyInspection_1.annotateDependencyBuildability)(loadedProject.projectRoot, [...dependencyRecords.values()].sort((left, right) => left.name.localeCompare(right.name)));
-    const blockingIssues = await collectBlockingIssues(loadedProject.projectRoot, loadedProject.expoConfig, loadedProject.packageJson, expoPlugins, expoSchemes, expoSdkVersion, dependencies, matrix, targetTier);
-    const capabilities = (0, capabilities_1.getCapabilityDefinitionsForProject)(loadedProject.packageJson).map((definition) => ({
+    const blockingIssues = await collectBlockingIssues(loadedProject.projectRoot, loadedProject.expoConfig, filteredPackageJson, expoPlugins, expoSchemes, expoSdkVersion, dependencies, matrix, targetTier);
+    const excludedDependencies = new Set(doctorConfig.excludeDependencies);
+    const capabilities = (0, capabilities_1.getCapabilityDefinitionsForProject)(filteredPackageJson, {
+        excludedDependencies,
+    }).map((definition) => ({
         id: definition.id,
         packageName: definition.packageName,
         status: definition.status,
@@ -59,7 +65,7 @@ async function buildDoctorReport(projectRoot, options = {}) {
         sampleRoute: definition.sampleRoute,
         acceptanceChecklist: [...definition.acceptanceChecklist],
     }));
-    const coverageProfile = await detectCoverageProfile(loadedProject.projectRoot, loadedProject.packageJson, dependencies);
+    const coverageProfile = await detectCoverageProfile(loadedProject.projectRoot, filteredPackageJson, dependencies, doctorConfig.coverageProfile);
     const blockingDependencyNames = new Set(blockingIssues
         .filter((issue) => issue.code.startsWith('dependency.') && issue.subject)
         .map((issue) => issue.subject));
@@ -76,7 +82,7 @@ async function buildDoctorReport(projectRoot, options = {}) {
         capabilities,
     });
     const warnings = buildWarnings(loadedProject.expoConfig, expoSdkVersion, resolvedDependencies);
-    const advisories = buildAdvisories(loadedProject.expoConfig);
+    const advisories = buildAdvisories(loadedProject.expoConfig, doctorConfig);
     return {
         generatedAt: new Date().toISOString(),
         projectRoot: loadedProject.projectRoot,
@@ -248,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}.`,
@@ -353,7 +367,10 @@ async function collectBlockingIssues(projectRoot, expoConfig, packageJson, expoP
     }
     return dedupeIssues(issues);
 }
-async function detectCoverageProfile(projectRoot, packageJson, dependencies) {
+async function detectCoverageProfile(projectRoot, packageJson, dependencies, coverageProfileOverride) {
+    if (coverageProfileOverride) {
+        return coverageProfileOverride;
+    }
     for (const directoryName of BARE_WORKFLOW_DIRECTORY_NAMES) {
         if (await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, directoryName))) {
             return 'bare';
@@ -490,8 +507,17 @@ function buildWarnings(expoConfig, expoSdkVersion, dependencies) {
     }
     return warnings;
 }
-function buildAdvisories(expoConfig) {
+function buildAdvisories(expoConfig, doctorConfig) {
     const advisories = [];
+    if (doctorConfig.excludeDependencies.length > 0) {
+        advisories.push(`Expo Harmony doctor excluded dependencies: ${doctorConfig.excludeDependencies.join(', ')}.`);
+    }
+    if (doctorConfig.excludePlugins.length > 0) {
+        advisories.push(`Expo Harmony doctor excluded plugins: ${doctorConfig.excludePlugins.join(', ')}.`);
+    }
+    if (doctorConfig.coverageProfile) {
+        advisories.push(`Expo Harmony doctor forced coverage profile to ${doctorConfig.coverageProfile}.`);
+    }
     if (!expoConfig.android?.package && expoConfig.ios?.bundleIdentifier) {
         advisories.push('The project is using ios.bundleIdentifier as the only explicit native identifier. Prefer setting android.package as well before claiming release readiness.');
     }
@@ -501,11 +527,21 @@ function isDependencyAllowedForTargetTier(dependencyName, matrix, targetTier) {
     if (matrix.allowedDependencies.includes(dependencyName)) {
         return true;
     }
+    const catalogRecord = dependencyCatalog_1.DEPENDENCY_CATALOG[dependencyName];
+    if (catalogRecord) {
+        return (0, capabilities_1.isSupportTierAllowed)(catalogRecord.supportTier, targetTier);
+    }
     const capability = capabilities_1.CAPABILITY_BY_PACKAGE[dependencyName];
-    if (!capability) {
+    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 (0, capabilities_1.isSupportTierAllowed)(capability.supportTier, targetTier);
+    return !isDependencyAllowedForTargetTier(dependency.name, matrix, targetTier);
 }
 function matchesVersionRange(rawVersion, range) {
     const coerced = semver_1.default.coerce(rawVersion);

package/build/core/template.js

@@ -135,9 +135,12 @@ async function syncProjectTemplate(projectRoot, force = false, options = {}) {
 }
 async function buildManagedFiles(loadedProject, identifiers, previousToolkitConfig, doctorReport) {
     const hasExpoRouter = (0, support_1.usesExpoRouter)(loadedProject.packageJson);
+    const doctorConfig = (0, project_1.resolveExpoHarmonyDoctorConfig)(loadedProject.expoConfig);
     const enabledCapabilities = doctorReport.capabilities;
     const hasManagedExpoHarmonyPackage = enabledCapabilities.some((capability) => capability.runtimeMode !== 'shim');
-    const requestedHarmonyPermissions = (0, capabilities_1.collectCapabilityHarmonyPermissions)(loadedProject.packageJson);
+    const requestedHarmonyPermissions = (0, capabilities_1.collectCapabilityHarmonyPermissions)(loadedProject.packageJson, {
+        excludedDependencies: new Set(doctorConfig.excludeDependencies),
+    });
     const signingLocalConfig = await (0, signing_1.readSigningLocalConfig)(loadedProject.projectRoot);
     const hvigorPluginFilename = await (0, project_1.resolveRnohHvigorPluginFilename)(loadedProject.projectRoot);
     const renderedHarmonyRootPackage = renderTemplate(await fs_extra_1.default.readFile(path_1.default.join(TEMPLATE_ROOT, 'oh-package.json5'), 'utf8'), loadedProject, identifiers, hvigorPluginFilename);
@@ -179,6 +182,7 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
         bundleName: identifiers.bundleName,
         entryModuleName: identifiers.entryModuleName,
         coverageProfile: doctorReport.coverageProfile,
+        doctorConfig,
         capabilities: enabledCapabilities.map((capability) => ({
             id: capability.id,
             packageName: capability.packageName,

package/build/data/capabilities.d.ts

@@ -3,5 +3,9 @@ export declare const CAPABILITY_DEFINITIONS: readonly CapabilityDefinition[];
 export declare const CAPABILITY_BY_PACKAGE: Record<string, CapabilityDefinition>;
 export declare function compareSupportTiers(left: SupportTier, right: SupportTier): number;
 export declare function isSupportTierAllowed(dependencyTier: SupportTier, targetTier: DoctorTargetTier): boolean;
-export declare function getCapabilityDefinitionsForProject(packageJson: PackageJson): CapabilityDefinition[];
-export declare function collectCapabilityHarmonyPermissions(packageJson: PackageJson): string[];
+export declare function getCapabilityDefinitionsForProject(packageJson: PackageJson, options?: {
+    excludedDependencies?: ReadonlySet<string>;
+}): CapabilityDefinition[];
+export declare function collectCapabilityHarmonyPermissions(packageJson: PackageJson, options?: {
+    excludedDependencies?: ReadonlySet<string>;
+}): string[];

package/build/data/capabilities.js

@@ -149,9 +149,13 @@ function compareSupportTiers(left, right) {
 function isSupportTierAllowed(dependencyTier, targetTier) {
     return compareSupportTiers(dependencyTier, targetTier) <= 0;
 }
-function getCapabilityDefinitionsForProject(packageJson) {
-    return exports.CAPABILITY_DEFINITIONS.filter((definition) => (0, project_1.hasDeclaredDependency)(packageJson, definition.packageName)).sort((left, right) => left.packageName.localeCompare(right.packageName));
+function getCapabilityDefinitionsForProject(packageJson, options = {}) {
+    const excludedDependencies = options.excludedDependencies ?? new Set();
+    return exports.CAPABILITY_DEFINITIONS.filter((definition) => !excludedDependencies.has(definition.packageName) &&
+        (0, project_1.hasDeclaredDependency)(packageJson, definition.packageName)).sort((left, right) => left.packageName.localeCompare(right.packageName));
 }
-function collectCapabilityHarmonyPermissions(packageJson) {
-    return Array.from(new Set(getCapabilityDefinitionsForProject(packageJson).flatMap((definition) => definition.harmonyPermissions))).sort((left, right) => left.localeCompare(right));
+function collectCapabilityHarmonyPermissions(packageJson, options = {}) {
+    return Array.from(new Set(getCapabilityDefinitionsForProject(packageJson, options)
+        .filter((definition) => definition.runtimeMode !== 'shim')
+        .flatMap((definition) => definition.harmonyPermissions))).sort((left, right) => left.localeCompare(right));
 }

package/build/data/dependencyCatalog.js

@@ -26,6 +26,29 @@ const UI_STACK_COMPATIBILITY_RECORDS = Object.fromEntries(uiStack_1.UI_STACK_VAL
         },
     ],
 ]));
+const UI_STACK_ADAPTER_PACKAGE_NAME_SET = new Set(uiStack_1.UI_STACK_VALIDATED_ADAPTERS.map((entry) => entry.adapterPackageName));
+const HARMONY_NATIVE_ADAPTER_COMPATIBILITY_RECORDS = Object.fromEntries(uiStack_1.HARMONY_NATIVE_ADAPTERS.filter((entry) => !UI_STACK_ADAPTER_PACKAGE_NAME_SET.has(entry.adapterPackageName)).flatMap((entry) => [
+    [
+        entry.canonicalPackageName,
+        {
+            status: 'manual',
+            supportTier: 'experimental',
+            note: `Harmony runtime support is tracked through ${entry.adapterPackageName}. Keep it on the experimental lane until bundle, debug HAP, and device evidence are recorded for the consuming app.`,
+            replacement: entry.adapterPackageName,
+            docsUrl: entry.docsUrl,
+        },
+    ],
+    [
+        entry.adapterPackageName,
+        {
+            status: 'manual',
+            supportTier: 'experimental',
+            note: `Harmony adapter package pinned by the ccnubox intake catalog. The toolkit can link its HAR when ${entry.harmonyHarFileName} is installed, but runtime behavior still needs app-level evidence.`,
+            replacement: entry.canonicalPackageName,
+            docsUrl: entry.docsUrl,
+        },
+    ],
+]));
 exports.DEPENDENCY_CATALOG = {
     [constants_1.TOOLKIT_PACKAGE_NAME]: {
         status: 'supported',
@@ -112,7 +135,32 @@ exports.DEPENDENCY_CATALOG = {
         supportTier: 'verified',
         note: 'File-based routing is treated as part of the validated App Shell matrix when router peers, scheme, and plugin config are present.',
     },
+    '@react-native-async-storage/async-storage': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Async storage is a high-frequency startup dependency. Treat it as an experimental Harmony intake dependency until the managed adapter path has stable doctor, sample, and build coverage.',
+        docsUrl: 'https://github.com/react-native-oh-library',
+    },
+    'react-native-safe-area-context': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'Safe-area handling is shimmed by the toolkit for Harmony so App Shell layouts can keep rendering while the native path remains outside the verified matrix.',
+        docsUrl: 'https://github.com/react-native-oh-library',
+    },
+    'react-native-screens': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Navigation stacks frequently depend on react-native-screens. Keep it on the experimental lane until the Harmony adapter path has repeatable sample and device coverage.',
+        docsUrl: 'https://github.com/react-native-oh-library',
+    },
+    'react-native-webview': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'WebView is a common app-shell blocker. Treat it as an experimental intake dependency until the Harmony runtime path is validated on device.',
+        docsUrl: 'https://github.com/react-native-oh-library',
+    },
     ...UI_STACK_COMPATIBILITY_RECORDS,
+    ...HARMONY_NATIVE_ADAPTER_COMPATIBILITY_RECORDS,
     'react-native-gesture-handler': {
         status: 'manual',
         supportTier: 'experimental',
@@ -127,6 +175,206 @@ exports.DEPENDENCY_CATALOG = {
         replacement: 'react-native-gesture-handler',
         docsUrl: 'https://github.com/react-native-oh-library/react-native-harmony-gesture-handler',
     },
+    '@ant-design/icons-react-native': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'Icon font rendering is accepted for the ccnubox intake path; font asset registration still needs bundle/debug validation on Harmony.',
+    },
+    '@ant-design/react-native': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'React Native UI components are JS-heavy, but the app must still validate modal, picker, and gesture surfaces on Harmony.',
+    },
+    '@bacons/apple-targets': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'iOS widget build tooling may be excluded from Harmony doctor because it does not participate in the Harmony runtime.',
+    },
+    '@expo/vector-icons': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'Vector icon rendering is accepted when paired with bundled icon fonts and a working Expo font path.',
+    },
+    '@lottiefiles/dotlottie-react': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'dotLottie usage remains an experimental animation surface until the app records Harmony runtime evidence.',
+    },
+    '@react-navigation/bottom-tabs': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'React Navigation tabs are accepted for the ccnubox app-shell path when paired with screens, safe-area, gesture, and reanimated validation.',
+    },
+    '@react-navigation/elements': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'React Navigation elements stay in the JS/UI layer but inherit the navigation-stack runtime evidence requirements.',
+    },
+    '@react-navigation/native': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'React Navigation native is accepted for managed Harmony intake when linking, safe-area, screens, and gesture dependencies are present.',
+    },
+    '@rneui/base': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'RNE base components are accepted as JS/UI dependencies and should be covered by app-level visual smoke tests.',
+    },
+    '@rneui/themed': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'RNE themed components are accepted as JS/UI dependencies and should be covered by app-level visual smoke tests.',
+    },
+    axios: {
+        status: 'supported',
+        supportTier: 'verified',
+        note: 'HTTP client dependency with no native surface.',
+    },
+    'expo-application': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Application metadata reads require Harmony verification because Expo native modules are outside the verified UI-stack matrix.',
+    },
+    'expo-blur': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Blur effects need visual verification on Harmony and are not part of the verified UI-stack matrix.',
+    },
+    'expo-clipboard': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Clipboard support should be routed through the Harmony clipboard adapter where the app needs real pasteboard access.',
+        replacement: '@react-native-oh-tpl/clipboard',
+    },
+    'expo-dev-client': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Dev-client native behavior is outside release eligibility; it may exist in the project without blocking experimental intake.',
+    },
+    'expo-font': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Font loading is accepted for ccnubox intake but must be validated with bundled icon/font assets in the Harmony HAP.',
+    },
+    'expo-haptics': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Haptics require a Harmony runtime implementation before the app can claim device parity.',
+    },
+    'expo-image': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Image rendering and cache behavior require Harmony bundle and device validation.',
+    },
+    'expo-image-manipulator': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Image manipulation remains an experimental ccnubox requirement for timetable screenshot/export flows.',
+    },
+    'expo-insights': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Telemetry should not block bundle intake, but Harmony runtime behavior remains outside the verified matrix.',
+    },
+    'expo-linear-gradient': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Gradient rendering requires visual smoke validation on Harmony.',
+    },
+    'expo-media-library': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Media-library write/read flows should be backed by the Harmony camera-roll adapter for screenshot save acceptance.',
+        replacement: '@react-native-oh-tpl/camera-roll',
+    },
+    'expo-secure-store': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Secure storage must use a real Harmony secure backend or equivalent encrypted wrapper before release parity is claimed.',
+    },
+    'expo-splash-screen': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Splash behavior is accepted for ccnubox intake but remains native-side runtime evidence.',
+    },
+    'expo-symbols': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Symbols are platform-specific visual assets and require Harmony fallback/runtime verification.',
+    },
+    'expo-system-ui': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'System UI updates touch native chrome and need Harmony runtime validation.',
+    },
+    'expo-updates': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'OTA update checks remain experimental on Harmony until update metadata and launch behavior are validated.',
+    },
+    'expo-web-browser': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'In-app browser flows need Harmony runtime validation; they must not replace WebView parity for pages that require injected scripts.',
+    },
+    'jcore-react-native': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'JCore is accepted as part of the JPush Harmony intake path, but device-side SDK evidence is required.',
+        docsUrl: 'https://docs.jiguang.cn/jpush/client/HarmonyOS/hmos_guide',
+    },
+    'jpush-react-native': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'JPush is a real runtime requirement for ccnubox. Keep it in the catalog and require a Harmony SDK bridge plus device evidence for registrationId, arrival, click, and cold-start payloads.',
+        docsUrl: 'https://docs.jiguang.cn/jpush/client/HarmonyOS/hmos_guide',
+    },
+    'mx-jpush-expo': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'The Expo config plugin may be excluded from Harmony config processing, but the JPush runtime dependency must stay visible in doctor reports.',
+        docsUrl: 'https://docs.jiguang.cn/jpush/client/HarmonyOS/hmos_guide',
+    },
+    'react-native-draggable-grid': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'Drag-grid behavior is accepted for the ccnubox homepage intake and requires gesture/runtime smoke validation.',
+    },
+    'react-native-edge-to-edge': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'Android edge-to-edge native configuration can be excluded as a config plugin; runtime chrome behavior remains Harmony-specific.',
+    },
+    'react-native-keyboard-aware-scroll-view': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'Keyboard-aware scrolling is accepted as JS/UI behavior but requires form-flow validation on Harmony.',
+    },
+    'react-native-pdf-renderer': {
+        status: 'manual',
+        supportTier: 'experimental',
+        note: 'PDF rendering is a native-looking app requirement and remains experimental until a Harmony renderer or adapter is validated.',
+    },
+    'react-native-reanimated-carousel': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'Carousel behavior is accepted when paired with the validated reanimated Harmony adapter and homepage smoke tests.',
+    },
+    'react-native-svg-transformer': {
+        status: 'supported',
+        supportTier: 'experimental',
+        note: 'Metro SVG transformation is accepted for bundling when paired with the validated react-native-svg Harmony adapter.',
+    },
+    'react-native-web': {
+        status: 'supported',
+        supportTier: 'verified',
+        note: 'Web support dependency has no Harmony native runtime surface.',
+    },
+    zustand: {
+        status: 'supported',
+        supportTier: 'verified',
+        note: 'State management dependency with no native surface.',
+    },
     ...Object.fromEntries(capabilities_1.CAPABILITY_DEFINITIONS.map((definition) => [
         definition.packageName,
         {

package/build/data/publicDocs.d.ts

@@ -8,4 +8,4 @@ export declare const SUPPORTING_SAMPLE_PATHS: readonly ["examples/official-app-s
 export declare const VERIFIED_JS_UI_CAPABILITY_NAMES: readonly ["expo-router", "expo-linking", "expo-constants", ...("react-native-reanimated" | "react-native-svg")[]];
 export declare const PREVIEW_CAPABILITY_DEFINITIONS: import("..").CapabilityDefinition[];
 export declare const EXPERIMENTAL_CAPABILITY_NAMES: readonly [...string[], "react-native-gesture-handler"];
-export declare const PUBLIC_CURRENT_VERSION = "1.8.0";
+export declare const PUBLIC_CURRENT_VERSION = "1.8.2";