expo-harmony-toolkit 1.7.2 → 1.8.0

package/build/core/template.js

@@ -3,27 +3,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BUILD_REQUIRED_MANAGED_FILE_PATHS = void 0;
+exports.BUILD_REQUIRED_MANAGED_FILE_PATHS = exports.usesExpoRouter = exports.resolveHarmonyBundleEntryFile = exports.buildDesiredPackageScripts = void 0;
 exports.initProject = initProject;
 exports.syncProjectTemplate = syncProjectTemplate;
-exports.normalizeKnownHarmonyPackageJsons = normalizeKnownHarmonyPackageJsons;
-exports.buildDesiredPackageScripts = buildDesiredPackageScripts;
-exports.usesExpoRouter = usesExpoRouter;
-exports.resolveHarmonyBundleEntryFile = resolveHarmonyBundleEntryFile;
 const fs_extra_1 = __importDefault(require("fs-extra"));
-const json5_1 = __importDefault(require("json5"));
-const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const semver_1 = __importDefault(require("semver"));
 const constants_1 = require("./constants");
 const validatedMatrices_1 = require("../data/validatedMatrices");
 const metadata_1 = require("./metadata");
 const capabilities_1 = require("../data/capabilities");
-const uiStack_1 = require("../data/uiStack");
 const project_1 = require("./project");
 const javascriptDependencies_1 = require("./javascriptDependencies");
 const report_1 = require("./report");
 const signing_1 = require("./signing");
+const autolinking_1 = require("./autolinking");
+const capabilityRegistry_1 = require("./template/capabilityRegistry");
+const expoModulesCoreShim_1 = require("./template/expoModulesCoreShim");
+const nativeFiles_1 = require("./template/nativeFiles");
+const metro_1 = require("./template/metro");
+const runtimeShims_1 = require("./template/runtimeShims");
+const support_1 = require("./template/support");
+const constants_2 = require("./constants");
+var support_2 = require("./template/support");
+Object.defineProperty(exports, "buildDesiredPackageScripts", { enumerable: true, get: function () { return support_2.buildDesiredPackageScripts; } });
+Object.defineProperty(exports, "resolveHarmonyBundleEntryFile", { enumerable: true, get: function () { return support_2.resolveHarmonyBundleEntryFile; } });
+Object.defineProperty(exports, "usesExpoRouter", { enumerable: true, get: function () { return support_2.usesExpoRouter; } });
 const TEMPLATE_ROOT = path_1.default.resolve(__dirname, '..', '..', 'templates', 'harmony');
 const TEMPLATE_FILE_PATHS = [
     'README.md',
@@ -53,35 +57,16 @@ const TEMPLATE_FILE_PATHS = [
     'entry/src/main/resources/base/profile/main_pages.json',
     'entry/src/main/resources/rawfile/.gitkeep',
 ];
-const AUTOLINKED_FILE_PATHS = [
-    path_1.default.join('harmony', 'oh-package.json5'),
-    path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'RNOHPackagesFactory.ets'),
-    path_1.default.join('harmony', 'entry', 'src', 'main', 'cpp', 'RNOHPackagesFactory.h'),
-    path_1.default.join('harmony', 'entry', 'src', 'main', 'cpp', 'autolinking.cmake'),
-];
 const RNOH_GENERATED_TS_SHIM_RELATIVE_PATH = path_1.default.join('harmony', 'oh_modules', '@rnoh', 'react-native-openharmony', 'ts.ts');
 exports.BUILD_REQUIRED_MANAGED_FILE_PATHS = [
-    ...AUTOLINKED_FILE_PATHS,
+    ...autolinking_1.AUTOLINKED_FILE_PATHS,
     RNOH_GENERATED_TS_SHIM_RELATIVE_PATH,
 ];
-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,
-        };
-    },
-};
 async function initProject(projectRoot, force = false) {
     const report = await (0, report_1.buildDoctorReport)(projectRoot);
-    const sync = await syncProjectTemplate(projectRoot, force);
+    const sync = await syncProjectTemplate(projectRoot, force, {
+        doctorReport: report,
+    });
     const packageWarnings = await syncPackageScripts(projectRoot, force);
     const doctorReportPath = await (0, report_1.writeDoctorReport)(projectRoot, report);
     return {
@@ -95,7 +80,8 @@ async function syncProjectTemplate(projectRoot, force = false, options = {}) {
     const loadedProject = await (0, project_1.loadProject)(projectRoot);
     const identifiers = (0, project_1.deriveHarmonyIdentifiers)(loadedProject.expoConfig, loadedProject.packageJson);
     const previousToolkitConfig = await (0, metadata_1.readToolkitConfig)(loadedProject.projectRoot);
-    const desiredFiles = await buildManagedFiles(loadedProject, identifiers, previousToolkitConfig);
+    const doctorReport = options.doctorReport ?? (await (0, report_1.buildDoctorReport)(loadedProject.projectRoot));
+    const desiredFiles = await buildManagedFiles(loadedProject, identifiers, previousToolkitConfig, doctorReport);
     const previousManifest = await (0, metadata_1.readManifest)(loadedProject.projectRoot);
     const forceManagedPaths = new Set(options.forceManagedPaths ?? []);
     const result = {
@@ -105,7 +91,7 @@ async function syncProjectTemplate(projectRoot, force = false, options = {}) {
         warnings: [],
         manifestPath: (0, metadata_1.getManifestPath)(loadedProject.projectRoot),
     };
-    result.warnings.push(...collectMetadataWarnings(previousManifest, previousToolkitConfig));
+    result.warnings.push(...(0, support_1.collectMetadataWarnings)(previousManifest, previousToolkitConfig));
     const manifestFiles = [];
     for (const file of desiredFiles) {
         const targetPath = path_1.default.join(loadedProject.projectRoot, file.relativePath);
@@ -113,7 +99,7 @@ async function syncProjectTemplate(projectRoot, force = false, options = {}) {
         const previousRecord = previousManifest?.files.find((record) => record.relativePath === file.relativePath);
         if (await fs_extra_1.default.pathExists(targetPath)) {
             const currentContents = await fs_extra_1.default.readFile(targetPath);
-            if (contentsEqual(currentContents, file.contents, file.binary)) {
+            if ((0, support_1.contentsEqual)(currentContents, file.contents, file.binary)) {
                 result.unchangedFiles.push(file.relativePath);
                 manifestFiles.push({ relativePath: file.relativePath, sha1: expectedHash });
                 continue;
@@ -147,9 +133,9 @@ async function syncProjectTemplate(projectRoot, force = false, options = {}) {
     await fs_extra_1.default.writeJson(result.manifestPath, manifest, { spaces: 2 });
     return result;
 }
-async function buildManagedFiles(loadedProject, identifiers, previousToolkitConfig) {
-    const hasExpoRouter = usesExpoRouter(loadedProject.packageJson);
-    const enabledCapabilities = (0, capabilities_1.getCapabilityDefinitionsForProject)(loadedProject.packageJson);
+async function buildManagedFiles(loadedProject, identifiers, previousToolkitConfig, doctorReport) {
+    const hasExpoRouter = (0, support_1.usesExpoRouter)(loadedProject.packageJson);
+    const enabledCapabilities = doctorReport.capabilities;
     const hasManagedExpoHarmonyPackage = enabledCapabilities.some((capability) => capability.runtimeMode !== 'shim');
     const requestedHarmonyPermissions = (0, capabilities_1.collectCapabilityHarmonyPermissions)(loadedProject.packageJson);
     const signingLocalConfig = await (0, signing_1.readSigningLocalConfig)(loadedProject.projectRoot);
@@ -157,7 +143,7 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
     const renderedHarmonyRootPackage = renderTemplate(await fs_extra_1.default.readFile(path_1.default.join(TEMPLATE_ROOT, 'oh-package.json5'), 'utf8'), loadedProject, identifiers, hvigorPluginFilename);
     const templateFiles = await Promise.all(TEMPLATE_FILE_PATHS.map(async (relativePath) => {
         const templatePath = path_1.default.join(TEMPLATE_ROOT, relativePath);
-        const binary = isBinaryTemplate(relativePath);
+        const binary = (0, support_1.isBinaryTemplate)(relativePath);
         const rawContents = await fs_extra_1.default.readFile(templatePath);
         const contents = binary
             ? rawContents
@@ -171,18 +157,18 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
                     : relativePath === 'entry/src/main/resources/base/element/string.json'
                         ? renderEntryStringResources(`${identifiers.appName} official minimal Harmony sample`, identifiers.appName, requestedHarmonyPermissions)
                         : relativePath === 'entry/src/main/ets/PackageProvider.ets'
-                            ? renderPackageProvider({
+                            ? (0, nativeFiles_1.renderPackageProvider)({
                                 hasManagedExpoHarmonyPackage,
                             })
                             : relativePath === 'entry/src/main/cpp/PackageProvider.cpp'
-                                ? renderPackageProviderCpp({
+                                ? (0, nativeFiles_1.renderPackageProviderCpp)({
                                     hasManagedExpoHarmonyPackage,
                                 })
                                 : contents,
             binary,
         };
     }));
-    const autolinkedFiles = await buildAutolinkedManagedFiles(loadedProject.projectRoot, renderedHarmonyRootPackage);
+    const autolinkedFiles = await (0, autolinking_1.buildAutolinkedManagedFiles)(loadedProject.projectRoot, renderedHarmonyRootPackage);
     const nextToolkitConfig = {
         generatedAt: new Date().toISOString(),
         toolkitVersion: constants_1.TOOLKIT_VERSION,
@@ -192,14 +178,17 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
         rnohCliVersion: constants_1.RNOH_CLI_VERSION,
         bundleName: identifiers.bundleName,
         entryModuleName: identifiers.entryModuleName,
+        coverageProfile: doctorReport.coverageProfile,
         capabilities: enabledCapabilities.map((capability) => ({
             id: capability.id,
             packageName: capability.packageName,
             supportTier: capability.supportTier,
             runtimeMode: capability.runtimeMode,
             evidence: { ...capability.evidence },
+            evidenceSource: { ...capability.evidenceSource },
         })),
         requestedHarmonyPermissions,
+        nextActions: [...doctorReport.nextActions],
         project: {
             name: loadedProject.expoConfig.name ?? identifiers.appName,
             slug: loadedProject.expoConfig.slug ?? identifiers.slug,
@@ -207,7 +196,7 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
             hvigorPluginFilename,
         },
     };
-    const toolkitConfig = stabilizeToolkitConfigTimestamp(previousToolkitConfig, nextToolkitConfig);
+    const toolkitConfig = (0, support_1.stabilizeToolkitConfigTimestamp)(previousToolkitConfig, nextToolkitConfig);
     return [
         ...templateFiles,
         ...autolinkedFiles,
@@ -217,29 +206,29 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
         },
         {
             relativePath: 'metro.harmony.config.js',
-            contents: renderMetroConfig(enabledCapabilities),
+            contents: (0, metro_1.renderMetroConfig)(enabledCapabilities),
         },
         {
             relativePath: path_1.default.join(constants_1.GENERATED_SHIMS_DIR, 'react-native-safe-area-context', 'index.js'),
-            contents: renderReactNativeSafeAreaContextHarmonyShim(),
+            contents: (0, runtimeShims_1.renderReactNativeSafeAreaContextHarmonyShim)(),
         },
         {
             relativePath: path_1.default.join(constants_1.GENERATED_SHIMS_DIR, 'expo-modules-core', 'index.js'),
-            contents: renderExpoModulesCoreHarmonyShim(loadedProject.expoConfig, identifiers),
+            contents: (0, expoModulesCoreShim_1.renderExpoModulesCoreHarmonyShim)(loadedProject.expoConfig, identifiers),
         },
         ...capabilities_1.CAPABILITY_DEFINITIONS.map((capability) => ({
             relativePath: path_1.default.join(constants_1.GENERATED_SHIMS_DIR, capability.packageName, 'index.js'),
-            contents: renderCapabilityModuleShim(capability),
+            contents: (0, capabilityRegistry_1.renderCapabilityModuleShim)(capability),
         })),
         {
             relativePath: constants_1.HARMONY_RUNTIME_PRELUDE_RELATIVE_PATH,
-            contents: renderHarmonyRuntimePrelude(),
+            contents: (0, runtimeShims_1.renderHarmonyRuntimePrelude)(),
         },
         ...(hasExpoRouter
             ? [
                 {
                     relativePath: constants_1.HARMONY_ROUTER_ENTRY_FILENAME,
-                    contents: renderRouterHarmonyEntry(identifiers),
+                    contents: (0, support_1.renderRouterHarmonyEntry)(identifiers),
                 },
             ]
             : []),
@@ -247,359 +236,33 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
             ? [
                 {
                     relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'cpp', 'expoHarmony', 'ExpoHarmonyPackage.h'),
-                    contents: renderExpoHarmonyCppPackage(),
+                    contents: (0, nativeFiles_1.renderExpoHarmonyCppPackage)(),
                 },
                 {
                     relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyPackage.ets'),
-                    contents: renderExpoHarmonyPackage(),
-                },
-                {
-                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyFileSystemTurboModule.ts'),
-                    contents: renderExpoHarmonyFileSystemTurboModule(),
-                },
-                {
-                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyImagePickerTurboModule.ts'),
-                    contents: renderExpoHarmonyImagePickerTurboModule(),
-                },
-                {
-                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyLocationTurboModule.ts'),
-                    contents: renderExpoHarmonyLocationTurboModule(),
-                },
-                {
-                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyCameraTurboModule.ts'),
-                    contents: renderExpoHarmonyCameraTurboModule(),
+                    contents: (0, nativeFiles_1.renderExpoHarmonyPackage)(),
                 },
+                ...capabilityRegistry_1.MANAGED_EXPO_HARMONY_MODULE_RENDERERS.map(({ filename, render }) => ({
+                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', filename),
+                    contents: render(),
+                })),
             ]
             : []),
         {
             relativePath: path_1.default.join(constants_1.GENERATED_DIR, constants_1.TOOLKIT_CONFIG_FILENAME),
             contents: JSON.stringify(toolkitConfig, null, 2) + '\n',
         },
-    ];
-}
-async function buildAutolinkedManagedFiles(projectRoot, harmonyRootPackageContents) {
-    const generated = await generateAutolinkingArtifacts(projectRoot, harmonyRootPackageContents);
-    return [
-        {
-            relativePath: AUTOLINKED_FILE_PATHS[0],
-            contents: generated.ohPackageContents,
-        },
-        {
-            relativePath: AUTOLINKED_FILE_PATHS[1],
-            contents: generated.etsFactoryContents,
-        },
-        {
-            relativePath: AUTOLINKED_FILE_PATHS[2],
-            contents: generated.cppFactoryContents,
-        },
         {
-            relativePath: AUTOLINKED_FILE_PATHS[3],
-            contents: generated.cmakeContents,
+            relativePath: path_1.default.join(constants_1.GENERATED_DIR, constants_2.SIGNING_LOCAL_EXAMPLE_FILENAME),
+            contents: (0, signing_1.renderSigningLocalExampleConfig)(),
         },
     ];
 }
-async function generateAutolinkingArtifacts(projectRoot, harmonyRootPackageContents) {
-    const rnohCliPackageJsonPath = resolveProjectPackageJson(projectRoot, '@react-native-oh/react-native-harmony-cli');
-    const managedOhPackageContents = await buildManagedHarmonyRootPackageContents(projectRoot, harmonyRootPackageContents);
-    const managedAutolinkingEntries = await resolveManagedAutolinkingEntries(projectRoot);
-    if (!rnohCliPackageJsonPath) {
-        return createEmptyAutolinkingArtifacts(managedOhPackageContents, managedAutolinkingEntries);
-    }
-    try {
-        const restoreNormalizedHarmonyPackageJsons = await normalizeKnownHarmonyPackageJsons(projectRoot);
-        try {
-            const temporaryRoot = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'expo-harmony-autolinking-'));
-            try {
-                const temporaryHarmonyRoot = path_1.default.join(temporaryRoot, 'harmony');
-                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);
-                const normalizedEtsFactoryContents = await normalizeAutolinkingEtsFactoryContents(projectRoot, await fs_extra_1.default.readFile(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'ets', 'RNOHPackagesFactory.ets'), 'utf8'));
-                const normalizedCppFactoryContents = await normalizeAutolinkingCppFactoryContents(projectRoot, await fs_extra_1.default.readFile(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'cpp', 'RNOHPackagesFactory.h'), 'utf8'));
-                const normalizedCmakeContents = await fs_extra_1.default.readFile(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'cpp', 'autolinking.cmake'), 'utf8');
-                return {
-                    ohPackageContents: managedOhPackageContents,
-                    etsFactoryContents: injectManagedAutolinkingIntoEtsFactory(normalizedEtsFactoryContents, managedAutolinkingEntries),
-                    cppFactoryContents: injectManagedAutolinkingIntoCppFactory(normalizedCppFactoryContents, managedAutolinkingEntries),
-                    cmakeContents: injectManagedAutolinkingIntoCmake(normalizedCmakeContents, managedAutolinkingEntries),
-                };
-            }
-            finally {
-                await fs_extra_1.default.remove(temporaryRoot);
-            }
-        }
-        finally {
-            await restoreNormalizedHarmonyPackageJsons();
-        }
-    }
-    catch {
-        return createEmptyAutolinkingArtifacts(managedOhPackageContents, managedAutolinkingEntries);
-    }
-}
-async function resolveManagedAutolinkingEntries(projectRoot) {
-    const entries = await Promise.all(uiStack_1.UI_STACK_VALIDATED_ADAPTERS.map(async (adapter) => {
-        if (adapter.supportsAutolinking || !adapter.managedAutolinking) {
-            return null;
-        }
-        const dependencySpecifier = await resolveHarmonyAdapterHarDependency(projectRoot, adapter.adapterPackageName);
-        if (!dependencySpecifier) {
-            return null;
-        }
-        return {
-            adapterPackageName: adapter.adapterPackageName,
-            ...adapter.managedAutolinking,
-        };
-    }));
-    return entries.filter((entry) => entry !== null);
-}
-async function normalizeKnownHarmonyPackageJsons(projectRoot) {
-    const originalContentsByPath = new Map();
-    for (const [packageName, normalizePackageJson] of Object.entries(HARMONY_PACKAGE_JSON_NORMALIZERS)) {
-        const packageJsonPath = resolveProjectPackageJson(projectRoot, packageName);
-        if (!packageJsonPath || originalContentsByPath.has(packageJsonPath)) {
-            continue;
-        }
-        try {
-            const currentContents = await fs_extra_1.default.readFile(packageJsonPath, 'utf8');
-            const packageJson = JSON.parse(currentContents);
-            const normalizedPackageJson = normalizePackageJson(packageJson);
-            if (!normalizedPackageJson) {
-                continue;
-            }
-            originalContentsByPath.set(packageJsonPath, currentContents);
-            await fs_extra_1.default.writeFile(packageJsonPath, JSON.stringify(normalizedPackageJson, null, 2) + '\n');
-        }
-        catch {
-            // Ignore malformed adapter package metadata and let downstream tooling surface the failure.
-        }
-    }
-    return async () => {
-        for (const [packageJsonPath, originalContents] of originalContentsByPath) {
-            await fs_extra_1.default.writeFile(packageJsonPath, originalContents);
-        }
-    };
-}
-async function normalizeAutolinkingEtsFactoryContents(projectRoot, contents) {
-    let normalizedContents = contents
-        .replace(/import type \{\s*RNPackageContext\s*,\s*RNOHPackage\s*\} from '@rnoh\/react-native-openharmony';/, "import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';")
-        .replace(/export function createRNOHPackages\(([^)]*)\):\s*RNOHPackage\[\]/, 'export function createRNOHPackages($1): RNPackage[]');
-    const gestureHandlerPackageJsonPath = resolveProjectPackageJson(projectRoot, '@react-native-oh-tpl/react-native-gesture-handler');
-    if (!gestureHandlerPackageJsonPath) {
-        return normalizedContents;
-    }
-    try {
-        const gestureHandlerPackageJson = (await fs_extra_1.default.readJson(gestureHandlerPackageJsonPath));
-        if (gestureHandlerPackageJson.harmony?.codegenConfig) {
-            return normalizedContents;
-        }
-    }
-    catch {
-        return normalizedContents;
-    }
-    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';";
-    });
-    if (!gestureHandlerPackageImportName) {
-        return normalizedContents;
-    }
-    return normalizedContents.replace(new RegExp(`new\\s+${escapeRegExp(gestureHandlerPackageImportName)}\\(ctx\\)`, 'g'), 'new GestureHandlerPackage(ctx)');
-}
-function injectManagedAutolinkingIntoEtsFactory(contents, entries) {
-    if (entries.length === 0) {
-        return contents;
-    }
-    const missingImports = entries
-        .filter((entry) => !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)`))
-        .map((entry) => `    new ${entry.etsPackageName}(ctx),`);
-    if (missingFactoryEntries.length > 0) {
-        contents = contents.replace(/return \[\n/, `return [\n${missingFactoryEntries.join('\n')}\n`);
-    }
-    return contents;
-}
-async function normalizeAutolinkingCppFactoryContents(projectRoot, contents) {
-    const gestureHandlerPackageJsonPath = resolveProjectPackageJson(projectRoot, '@react-native-oh-tpl/react-native-gesture-handler');
-    if (!gestureHandlerPackageJsonPath) {
-        return contents;
-    }
-    try {
-        const gestureHandlerPackageJson = (await fs_extra_1.default.readJson(gestureHandlerPackageJsonPath));
-        if (gestureHandlerPackageJson.harmony?.codegenConfig) {
-            return contents;
-        }
-    }
-    catch {
-        return contents;
-    }
-    return contents
-        .replace(/#include "ReactNativeOhTplReactNativeGestureHandlerPackage\.h"/, '#include "RnohReactNativeHarmonyGestureHandlerPackage.h"')
-        .replace(/\brnoh::ReactNativeOhTplReactNativeGestureHandlerPackage\b/g, 'rnoh::RnohReactNativeHarmonyGestureHandlerPackage');
-}
-function injectManagedAutolinkingIntoCppFactory(contents, entries) {
-    if (entries.length === 0) {
-        return contents;
-    }
-    const missingIncludes = entries
-        .filter((entry) => !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)`))
-        .map((entry) => `    std::make_shared<rnoh::${entry.cppPackageName}>(ctx),`);
-    if (missingFactoryEntries.length > 0) {
-        contents = contents.replace(/return \{\n/, `return {\n${missingFactoryEntries.join('\n')}\n`);
-    }
-    return contents;
-}
-function injectManagedAutolinkingIntoCmake(contents, entries) {
-    if (entries.length === 0) {
-        return contents;
-    }
-    const missingSubdirectories = entries
-        .filter((entry) => !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}`))
-        .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) {
-    const rnohCliRoot = path_1.default.dirname(rnohCliPackageJsonPath);
-    const { commandLinkHarmony } = require(path_1.default.join(rnohCliRoot, 'dist', 'commands', 'link-harmony.js'));
-    await commandLinkHarmony.func([], {}, {
-        harmonyProjectPath,
-        nodeModulesPath: path_1.default.join(projectRoot, 'node_modules'),
-        cmakeAutolinkPathRelativeToHarmony: './entry/src/main/cpp/autolinking.cmake',
-        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,
-    });
-}
-async function buildManagedHarmonyRootPackageContents(projectRoot, harmonyRootPackageContents) {
-    const parsedPackageJson = json5_1.default.parse(harmonyRootPackageContents);
-    const dependencies = {
-        ...(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;
-        }
-    }
-    parsedPackageJson.dependencies = sortRecordByKey(dependencies);
-    return json5_1.default.stringify(parsedPackageJson, null, 2) + '\n';
-}
-async function readPreservedHarmonyRootDependencies(projectRoot) {
-    const harmonyRootPackagePath = path_1.default.join(projectRoot, 'harmony', 'oh-package.json5');
-    if (!(await fs_extra_1.default.pathExists(harmonyRootPackagePath))) {
-        return {};
-    }
-    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);
-    for (const [packageName, specifier] of Object.entries(currentHarmonyRootPackage.dependencies ?? {})) {
-        if (typeof specifier !== 'string') {
-            continue;
-        }
-        if (validatedAdapterPackageNames.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);
-    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}`;
-}
-function createEmptyAutolinkingArtifacts(harmonyRootPackageContents, managedAutolinkingEntries) {
-    return {
-        ohPackageContents: harmonyRootPackageContents,
-        etsFactoryContents: injectManagedAutolinkingIntoEtsFactory(`/*
- * This file was generated by Expo Harmony Toolkit autolinking.
- * DO NOT modify it manually, your changes WILL be overwritten.
- */
-import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';
-
-export function createRNOHPackages(_ctx: RNPackageContext): RNPackage[] {
-  return [];
-}
-`, managedAutolinkingEntries),
-        cppFactoryContents: injectManagedAutolinkingIntoCppFactory(`/*
- * This file was generated by Expo Harmony Toolkit autolinking.
- * DO NOT modify it manually, your changes WILL be overwritten.
- */
-#pragma once
-#include "RNOH/Package.h"
-
-std::vector<rnoh::Package::Shared> createRNOHPackages(const rnoh::Package::Context &_ctx) {
-  return {};
-}
-`, managedAutolinkingEntries),
-        cmakeContents: injectManagedAutolinkingIntoCmake(`# This file was generated by Expo Harmony Toolkit autolinking.
-# DO NOT modify it manually, your changes WILL be overwritten.
-cmake_minimum_required(VERSION 3.5)
-
-function(autolink_libraries target)
-  set(AUTOLINKED_LIBRARIES
-  )
-
-  foreach(lib \${AUTOLINKED_LIBRARIES})
-    target_link_libraries(\${target} PUBLIC \${lib})
-  endforeach()
-endfunction()
-`, managedAutolinkingEntries),
-    };
-}
-function resolveProjectPackageJson(projectRoot, request) {
-    const directPackageJsonPath = path_1.default.join(projectRoot, 'node_modules', ...request.split('/'), 'package.json');
-    if (fs_extra_1.default.existsSync(directPackageJsonPath)) {
-        return directPackageJsonPath;
-    }
-    try {
-        return require.resolve(path_1.default.join(request, 'package.json'), {
-            paths: [projectRoot],
-        });
-    }
-    catch {
-        return null;
-    }
-}
 async function syncPackageScripts(projectRoot, _force) {
     const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
     const packageJson = (await fs_extra_1.default.readJson(packageJsonPath));
-    const desiredScripts = buildDesiredPackageScripts(packageJson);
-    const desiredPnpmOverrides = buildDesiredPnpmOverrides(packageJson);
+    const desiredScripts = (0, support_1.buildDesiredPackageScripts)(packageJson);
     const scripts = { ...(packageJson.scripts ?? {}) };
-    const pnpm = packageJson.pnpm && typeof packageJson.pnpm === 'object' ? { ...packageJson.pnpm } : {};
-    const pnpmOverrides = { ...(pnpm.overrides ?? {}) };
     const warnings = [];
     let didChange = false;
     for (const [scriptName, desiredCommand] of Object.entries(desiredScripts)) {
@@ -612,29 +275,13 @@ async function syncPackageScripts(projectRoot, _force) {
         if (currentCommand === desiredCommand) {
             continue;
         }
-        if (isEquivalentToolkitScript(scriptName, currentCommand, desiredCommand)) {
+        if ((0, support_1.isEquivalentToolkitScript)(scriptName, currentCommand, desiredCommand)) {
             continue;
         }
         warnings.push(`Left package.json script "${scriptName}" unchanged because it already exists with different contents.`);
     }
-    for (const [packageName, desiredSpecifier] of Object.entries(desiredPnpmOverrides)) {
-        const currentSpecifier = pnpmOverrides[packageName];
-        if (!currentSpecifier) {
-            pnpmOverrides[packageName] = desiredSpecifier;
-            didChange = true;
-            continue;
-        }
-        if (currentSpecifier === desiredSpecifier) {
-            continue;
-        }
-        warnings.push(`Left package.json pnpm.overrides["${packageName}"] unchanged because it already exists with different contents.`);
-    }
     if (didChange) {
-        packageJson.scripts = sortRecordByKey(scripts);
-        if (Object.keys(pnpmOverrides).length > 0) {
-            pnpm.overrides = sortRecordByKey(pnpmOverrides);
-            packageJson.pnpm = pnpm;
-        }
+        packageJson.scripts = (0, support_1.sortRecordByKey)(scripts);
         await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
         await fs_extra_1.default.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
     }
@@ -765,4058 +412,3 @@ function renderEntryStringResources(appDescription, appName, requestedHarmonyPer
         string: stringEntries,
     }, null, 2) + '\n';
 }
-function renderPackageProvider(options) {
-    const managedImports = options.hasManagedExpoHarmonyPackage
-        ? "import { ExpoHarmonyPackage } from './expoHarmony/ExpoHarmonyPackage';\n"
-        : '';
-    const managedPackages = options.hasManagedExpoHarmonyPackage ? ', new ExpoHarmonyPackage(ctx)' : '';
-    return `import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';
-import { createRNOHPackages as createRNOHPackagesAutolinking } from './RNOHPackagesFactory';
-${managedImports}
-export function getRNOHPackages(ctx: RNPackageContext): RNPackage[] {
-  return [...createRNOHPackagesAutolinking(ctx)${managedPackages}];
-}
-`;
-}
-function renderPackageProviderCpp(options) {
-    const managedInclude = options.hasManagedExpoHarmonyPackage
-        ? '#include "expoHarmony/ExpoHarmonyPackage.h"\n'
-        : '';
-    const managedPackage = options.hasManagedExpoHarmonyPackage
-        ? '  packages.push_back(std::make_shared<ExpoHarmonyPackage>(ctx));\n'
-        : '';
-    return `#include "RNOH/PackageProvider.h"
-#include "RNOHPackagesFactory.h"
-#include "generated/RNOHGeneratedPackage.h"
-${managedInclude}
-using namespace rnoh;
-
-std::vector<std::shared_ptr<Package>> PackageProvider::getPackages(
-    Package::Context ctx) {
-  auto packages = createRNOHPackages(ctx);
-  packages.push_back(std::make_shared<RNOHGeneratedPackage>(ctx));
-${managedPackage}  return packages;
-}
-`;
-}
-function renderExpoHarmonyCppPackage() {
-    return `#pragma once
-
-#include <ReactCommon/TurboModule.h>
-#include <react/renderer/components/view/ConcreteViewShadowNode.h>
-#include <react/renderer/core/ConcreteComponentDescriptor.h>
-#include "RNOH/ArkTSTurboModule.h"
-#include "RNOH/Package.h"
-#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
-
-namespace rnoh {
-using namespace facebook;
-
-inline constexpr char ExpoHarmonyCameraViewComponentName[] =
-    "ExpoHarmonyCameraView";
-using ExpoHarmonyCameraViewShadowNode =
-    react::ConcreteViewShadowNode<ExpoHarmonyCameraViewComponentName>;
-using ExpoHarmonyCameraViewComponentDescriptor =
-    react::ConcreteComponentDescriptor<ExpoHarmonyCameraViewShadowNode>;
-
-static jsi::Value __hostFunction_ExpoHarmonyFileSystemTurboModule_getConstants(
-    jsi::Runtime& rt,
-    react::TurboModule& turboModule,
-    const jsi::Value* args,
-    size_t count) {
-  return static_cast<ArkTSTurboModule&>(turboModule)
-      .call(rt, "getConstants", args, count);
-}
-
-static jsi::Value __hostFunction_ExpoHarmonyImagePickerTurboModule_getConstants(
-    jsi::Runtime& rt,
-    react::TurboModule& turboModule,
-    const jsi::Value* args,
-    size_t count) {
-  return static_cast<ArkTSTurboModule&>(turboModule)
-      .call(rt, "getConstants", args, count);
-}
-
-static jsi::Value __hostFunction_ExpoHarmonyLocationTurboModule_getConstants(
-    jsi::Runtime& rt,
-    react::TurboModule& turboModule,
-    const jsi::Value* args,
-    size_t count) {
-  return static_cast<ArkTSTurboModule&>(turboModule)
-      .call(rt, "getConstants", args, count);
-}
-
-static jsi::Value __hostFunction_ExpoHarmonyCameraTurboModule_getConstants(
-    jsi::Runtime& rt,
-    react::TurboModule& turboModule,
-    const jsi::Value* args,
-    size_t count) {
-  return static_cast<ArkTSTurboModule&>(turboModule)
-      .call(rt, "getConstants", args, count);
-}
-
-class JSI_EXPORT ExpoHarmonyFileSystemTurboModule : public ArkTSTurboModule {
- public:
-  ExpoHarmonyFileSystemTurboModule(
-      const ArkTSTurboModule::Context ctx,
-      const std::string name)
-      : ArkTSTurboModule(ctx, name) {
-    methodMap_["getConstants"] = MethodMetadata{
-        0, __hostFunction_ExpoHarmonyFileSystemTurboModule_getConstants};
-    methodMap_["getInfo"] = MethodMetadata{2, ARK_ASYNC_METHOD_CALLER(getInfo)};
-    methodMap_["readAsString"] = MethodMetadata{
-        2, ARK_ASYNC_METHOD_CALLER(readAsString)};
-    methodMap_["writeAsString"] = MethodMetadata{
-        3, ARK_ASYNC_METHOD_CALLER(writeAsString)};
-    methodMap_["deletePath"] = MethodMetadata{
-        2, ARK_ASYNC_METHOD_CALLER(deletePath)};
-    methodMap_["makeDirectory"] = MethodMetadata{
-        2, ARK_ASYNC_METHOD_CALLER(makeDirectory)};
-    methodMap_["readDirectory"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(readDirectory)};
-    methodMap_["copy"] = MethodMetadata{2, ARK_ASYNC_METHOD_CALLER(copy)};
-    methodMap_["move"] = MethodMetadata{2, ARK_ASYNC_METHOD_CALLER(move)};
-    methodMap_["download"] = MethodMetadata{
-        3, ARK_ASYNC_METHOD_CALLER(download)};
-  }
-};
-
-class JSI_EXPORT ExpoHarmonyImagePickerTurboModule : public ArkTSTurboModule {
- public:
-  ExpoHarmonyImagePickerTurboModule(
-      const ArkTSTurboModule::Context ctx,
-      const std::string name)
-      : ArkTSTurboModule(ctx, name) {
-    methodMap_["getConstants"] = MethodMetadata{
-        0, __hostFunction_ExpoHarmonyImagePickerTurboModule_getConstants};
-    methodMap_["getMediaLibraryPermissionStatus"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(getMediaLibraryPermissionStatus)};
-    methodMap_["requestMediaLibraryPermission"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(requestMediaLibraryPermission)};
-    methodMap_["getCameraPermissionStatus"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(getCameraPermissionStatus)};
-    methodMap_["requestCameraPermission"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(requestCameraPermission)};
-    methodMap_["launchImageLibrary"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(launchImageLibrary)};
-    methodMap_["launchCamera"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(launchCamera)};
-    methodMap_["getPendingResult"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(getPendingResult)};
-  }
-};
-
-class JSI_EXPORT ExpoHarmonyLocationTurboModule : public ArkTSTurboModule {
- public:
-  ExpoHarmonyLocationTurboModule(
-      const ArkTSTurboModule::Context ctx,
-      const std::string name)
-      : ArkTSTurboModule(ctx, name) {
-    methodMap_["getConstants"] = MethodMetadata{
-        0, __hostFunction_ExpoHarmonyLocationTurboModule_getConstants};
-    methodMap_["getForegroundPermissionStatus"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(getForegroundPermissionStatus)};
-    methodMap_["requestForegroundPermission"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(requestForegroundPermission)};
-    methodMap_["getBackgroundPermissionStatus"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(getBackgroundPermissionStatus)};
-    methodMap_["requestBackgroundPermission"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(requestBackgroundPermission)};
-    methodMap_["hasServicesEnabled"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(hasServicesEnabled)};
-    methodMap_["getProviderStatus"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(getProviderStatus)};
-    methodMap_["getCurrentPosition"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(getCurrentPosition)};
-    methodMap_["getLastKnownPosition"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(getLastKnownPosition)};
-    methodMap_["geocode"] = MethodMetadata{1, ARK_ASYNC_METHOD_CALLER(geocode)};
-    methodMap_["reverseGeocode"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(reverseGeocode)};
-    methodMap_["startWatchPosition"] = MethodMetadata{
-        2, ARK_ASYNC_METHOD_CALLER(startWatchPosition)};
-    methodMap_["stopWatchPosition"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(stopWatchPosition)};
-    methodMap_["getHeading"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(getHeading)};
-    methodMap_["startWatchHeading"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(startWatchHeading)};
-    methodMap_["stopWatchHeading"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(stopWatchHeading)};
-  }
-};
-
-class JSI_EXPORT ExpoHarmonyCameraTurboModule : public ArkTSTurboModule {
- public:
-  ExpoHarmonyCameraTurboModule(
-      const ArkTSTurboModule::Context ctx,
-      const std::string name)
-      : ArkTSTurboModule(ctx, name) {
-    methodMap_["getConstants"] = MethodMetadata{
-        0, __hostFunction_ExpoHarmonyCameraTurboModule_getConstants};
-    methodMap_["getCameraPermissionStatus"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(getCameraPermissionStatus)};
-    methodMap_["requestCameraPermission"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(requestCameraPermission)};
-    methodMap_["getMicrophonePermissionStatus"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(getMicrophonePermissionStatus)};
-    methodMap_["requestMicrophonePermission"] = MethodMetadata{
-        0, ARK_ASYNC_METHOD_CALLER(requestMicrophonePermission)};
-    methodMap_["createPreview"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(createPreview)};
-    methodMap_["disposePreview"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(disposePreview)};
-    methodMap_["pausePreview"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(pausePreview)};
-    methodMap_["resumePreview"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(resumePreview)};
-    methodMap_["takePicture"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(takePicture)};
-    methodMap_["startRecording"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(startRecording)};
-    methodMap_["stopRecording"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(stopRecording)};
-    methodMap_["toggleRecording"] = MethodMetadata{
-        1, ARK_ASYNC_METHOD_CALLER(toggleRecording)};
-  }
-};
-
-class ExpoHarmonyTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
- public:
-  SharedTurboModule createTurboModule(Context ctx, const std::string& name)
-      const override {
-    if (name == "ExpoHarmonyFileSystem") {
-      return std::make_shared<ExpoHarmonyFileSystemTurboModule>(ctx, name);
-    }
-    if (name == "ExpoHarmonyImagePicker") {
-      return std::make_shared<ExpoHarmonyImagePickerTurboModule>(ctx, name);
-    }
-    if (name == "ExpoHarmonyLocation") {
-      return std::make_shared<ExpoHarmonyLocationTurboModule>(ctx, name);
-    }
-    if (name == "ExpoHarmonyCamera") {
-      return std::make_shared<ExpoHarmonyCameraTurboModule>(ctx, name);
-    }
-
-    return nullptr;
-  }
-};
-
-class ExpoHarmonyCameraViewJSIBinder : public ViewComponentJSIBinder {
- protected:
-  facebook::jsi::Object createNativeProps(facebook::jsi::Runtime& rt) override {
-    auto nativeProps = ViewComponentJSIBinder::createNativeProps(rt);
-    nativeProps.setProperty(rt, "viewId", "string");
-    nativeProps.setProperty(rt, "facing", "string");
-    nativeProps.setProperty(rt, "mode", "string");
-    return nativeProps;
-  }
-};
-
-class ExpoHarmonyPackage : public Package {
- public:
-  explicit ExpoHarmonyPackage(Package::Context ctx) : Package(ctx) {}
-
-  std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate()
-      override {
-    return std::make_unique<ExpoHarmonyTurboModuleFactoryDelegate>();
-  }
-
-  std::vector<facebook::react::ComponentDescriptorProvider>
-  createComponentDescriptorProviders() override {
-    return {
-        facebook::react::concreteComponentDescriptorProvider<
-            ExpoHarmonyCameraViewComponentDescriptor>(),
-    };
-  }
-
-  ComponentJSIBinderByString createComponentJSIBinderByName() override {
-    auto binder = std::make_shared<ExpoHarmonyCameraViewJSIBinder>();
-    return {
-        {"ExpoHarmonyCameraView", binder},
-    };
-  }
-};
-} // namespace rnoh
-`;
-}
-function renderCapabilityModuleShim(capability) {
-    switch (capability.packageName) {
-        case 'expo-file-system':
-            return capability.runtimeMode !== 'shim'
-                ? renderExpoFileSystemHarmonyAdapterShim(capability)
-                : renderExpoFileSystemPreviewShim(capability);
-        case 'expo-image-picker':
-            return capability.runtimeMode !== 'shim'
-                ? renderExpoImagePickerHarmonyAdapterShim(capability)
-                : renderExpoImagePickerPreviewShim(capability);
-        case 'expo-location':
-            return capability.runtimeMode !== 'shim'
-                ? renderExpoLocationHarmonyAdapterShim(capability)
-                : renderExpoLocationPreviewShim(capability);
-        case 'expo-camera':
-            return capability.runtimeMode !== 'shim'
-                ? renderExpoCameraHarmonyAdapterShim(capability)
-                : renderExpoCameraPreviewShim(capability);
-        default:
-            return renderUnsupportedCapabilityShim(capability);
-    }
-}
-function renderMetroConfig(enabledCapabilities) {
-    const previewCapabilityAliases = enabledCapabilities
-        .filter((capability) => capability.supportTier === 'preview' || capability.supportTier === 'experimental')
-        .map((capability) => `  '${capability.packageName}': path.resolve(__dirname, '.expo-harmony/shims/${capability.packageName}'),`)
-        .join('\n');
-    return `const fs = require('fs');
-const path = require('path');
-
-process.env.EXPO_ROUTER_APP_ROOT = process.env.EXPO_ROUTER_APP_ROOT ?? 'app';
-
-const { getDefaultConfig } = require('expo/metro-config');
-const { createHarmonyMetroConfig } = require('@react-native-oh/react-native-harmony/metro.config');
-
-const defaultConfig = getDefaultConfig(__dirname);
-const harmonyConfig = createHarmonyMetroConfig({
-  reactNativeHarmonyPackageName: '@react-native-oh/react-native-harmony',
-});
-const expoHarmonyShims = {
-  'expo-modules-core': path.resolve(__dirname, '.expo-harmony/shims/expo-modules-core'),
-  'react-native-safe-area-context': path.resolve(
-    __dirname,
-    '.expo-harmony/shims/react-native-safe-area-context',
-  ),
-${previewCapabilityAliases ? `${previewCapabilityAliases}\n` : ''}};
-const uiStackRootModuleAliases = {
-  'react-native-gesture-handler': path.resolve(__dirname, 'node_modules/react-native-gesture-handler'),
-  'react-native-reanimated': path.resolve(__dirname, 'node_modules/react-native-reanimated'),
-  'react-native-svg': path.resolve(__dirname, 'node_modules/react-native-svg'),
-};
-const resolvePackageAlias = (context, moduleName, platform, aliases) => {
-  for (const [aliasedModuleName, aliasedModulePath] of Object.entries(aliases)) {
-    if (moduleName === aliasedModuleName) {
-      return context.resolveRequest(context, aliasedModulePath, platform);
-    }
-
-    if (moduleName.startsWith(\`\${aliasedModuleName}/\`)) {
-      return context.resolveRequest(
-        context,
-        path.join(aliasedModulePath, moduleName.slice(aliasedModuleName.length + 1)),
-        platform,
-      );
-    }
-  }
-
-  return null;
-};
-const resolveUiStackModuleAlias = (context, moduleName, platform) =>
-  resolvePackageAlias(context, moduleName, platform, uiStackRootModuleAliases);
-const resolveExpoHarmonyModuleAlias = (context, moduleName, platform) =>
-  resolvePackageAlias(context, moduleName, platform, expoHarmonyShims);
-const reactNativeCompatibilitySourceExts = ['js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'json'];
-const reactNativeCompatibilityPackageMarkers = [
-  path.sep + '@react-native-oh' + path.sep + 'react-native-harmony' + path.sep,
-  path.sep + 'react-native' + path.sep,
-];
-const findFirstExistingCompatibilityModule = (candidateBasePath, platforms) => {
-  for (const candidatePlatform of platforms) {
-    for (const candidateExtension of reactNativeCompatibilitySourceExts) {
-      const candidatePath = candidatePlatform
-        ? \`\${candidateBasePath}.\${candidatePlatform}.\${candidateExtension}\`
-        : \`\${candidateBasePath}.\${candidateExtension}\`;
-
-      if (fs.existsSync(candidatePath)) {
-        return { candidatePath, candidatePlatform };
-      }
-    }
-  }
-
-  return null;
-};
-const resolveReactNativeCompatibilityWrapper = (context, moduleName, platform) => {
-  if (platform !== 'harmony' || !context.originModulePath || !moduleName.startsWith('.')) {
-    return null;
-  }
-
-  const originModulePath = context.originModulePath;
-  const isReactNativeCompatibilityWrapper = reactNativeCompatibilityPackageMarkers.some((marker) =>
-    originModulePath.includes(marker),
-  );
-
-  if (!isReactNativeCompatibilityWrapper) {
-    return null;
-  }
-
-  const originExtension = path.extname(originModulePath);
-  const originBasename = path.basename(originModulePath, originExtension);
-  const candidateModulePath = path.resolve(path.dirname(originModulePath), moduleName);
-  const candidateModuleExtension = path.extname(candidateModulePath);
-  const candidateBasename = path.basename(candidateModulePath, candidateModuleExtension);
-
-  const candidateBasePath = candidateModuleExtension
-    ? candidateModulePath.slice(0, -candidateModuleExtension.length)
-    : candidateModulePath;
-
-  if (candidateBasename === originBasename) {
-    const compatibilityWrapperCandidate = findFirstExistingCompatibilityModule(candidateBasePath, [
-      'harmony',
-      'native',
-      'android',
-      'ios',
-    ]);
-
-    if (compatibilityWrapperCandidate) {
-      return context.resolveRequest(
-        context,
-        compatibilityWrapperCandidate.candidatePath,
-        compatibilityWrapperCandidate.candidatePlatform || platform,
-      );
-    }
-
-    return null;
-  }
-
-  const standardResolutionCandidate = findFirstExistingCompatibilityModule(candidateBasePath, [
-    'harmony',
-    'native',
-    '',
-  ]);
-
-  if (standardResolutionCandidate) {
-    return null;
-  }
-
-  const compatibilityFallbackCandidate = findFirstExistingCompatibilityModule(candidateBasePath, [
-    'android',
-    'ios',
-  ]);
-
-  if (compatibilityFallbackCandidate) {
-    return context.resolveRequest(
-      context,
-      compatibilityFallbackCandidate.candidatePath,
-      compatibilityFallbackCandidate.candidatePlatform || platform,
-    );
-  }
-
-  return null;
-};
-const resolveExpoHarmonyShim = (context, moduleName, platform) => {
-  const uiStackModuleAliasResolution = resolveUiStackModuleAlias(context, moduleName, platform);
-
-  if (uiStackModuleAliasResolution) {
-    return uiStackModuleAliasResolution;
-  }
-
-  const expoHarmonyModuleAliasResolution = resolveExpoHarmonyModuleAlias(context, moduleName, platform);
-
-  if (expoHarmonyModuleAliasResolution) {
-    return expoHarmonyModuleAliasResolution;
-  }
-
-  const compatibilityWrapperResolution = resolveReactNativeCompatibilityWrapper(
-    context,
-    moduleName,
-    platform,
-  );
-
-  if (compatibilityWrapperResolution) {
-    return compatibilityWrapperResolution;
-  }
-
-  const harmonyResolveRequest = harmonyConfig.resolver?.resolveRequest;
-
-  if (typeof harmonyResolveRequest === 'function') {
-    return harmonyResolveRequest(context, moduleName, platform);
-  }
-
-  return context.resolveRequest(context, moduleName, platform);
-};
-
-module.exports = {
-  ...defaultConfig,
-  ...harmonyConfig,
-  projectRoot: __dirname,
-  server: {
-    ...(defaultConfig.server ?? {}),
-    ...(harmonyConfig.server ?? {}),
-    unstable_serverRoot: __dirname,
-  },
-  transformer: {
-    ...(defaultConfig.transformer ?? {}),
-    ...(harmonyConfig.transformer ?? {}),
-  },
-  serializer: {
-    ...(defaultConfig.serializer ?? {}),
-    ...(harmonyConfig.serializer ?? {}),
-  },
-  resolver: {
-    ...(defaultConfig.resolver ?? {}),
-    ...(harmonyConfig.resolver ?? {}),
-    extraNodeModules: {
-      ...((defaultConfig.resolver?.extraNodeModules ?? {})),
-      ...((harmonyConfig.resolver?.extraNodeModules ?? {})),
-      ...uiStackRootModuleAliases,
-      ...expoHarmonyShims,
-    },
-    resolveRequest: resolveExpoHarmonyShim,
-    sourceExts: [
-      'harmony.ts',
-      'harmony.tsx',
-      'harmony.js',
-      'harmony.jsx',
-      ...((harmonyConfig.resolver?.sourceExts ?? defaultConfig.resolver?.sourceExts ?? ['ts', 'tsx', 'js', 'jsx', 'json'])),
-    ],
-  },
-};
-`;
-}
-function renderUnsupportedCapabilityShim(capability) {
-    return `'use strict';
-
-const { CodedError } = require('expo-modules-core');
-
-function createPreviewError() {
-  return new CodedError(
-    'ERR_EXPO_HARMONY_PREVIEW',
-    '${capability.packageName} is classified as ${capability.supportTier} for Harmony, but no managed runtime shim has been wired yet.',
-  );
-}
-
-function unavailable() {
-  throw createPreviewError();
-}
-
-module.exports = new Proxy(
-  {},
-  {
-    get(_target, propertyName) {
-      if (propertyName === '__esModule') {
-        return true;
-      }
-
-      return unavailable;
-    },
-  },
-);
-`;
-}
-function renderExpoHarmonyPackage() {
-    return `import type {
-  AnyThreadTurboModule,
-  AnyThreadTurboModuleContext,
-  UITurboModule,
-  UITurboModuleContext,
-} from '@rnoh/react-native-openharmony';
-import {
-  RNOHPackage,
-} from '@rnoh/react-native-openharmony';
-import { ExpoHarmonyFileSystemTurboModule } from './ExpoHarmonyFileSystemTurboModule';
-import { ExpoHarmonyImagePickerTurboModule } from './ExpoHarmonyImagePickerTurboModule';
-import { ExpoHarmonyLocationTurboModule } from './ExpoHarmonyLocationTurboModule';
-import { ExpoHarmonyCameraTurboModule } from './ExpoHarmonyCameraTurboModule';
-
-export class ExpoHarmonyPackage extends RNOHPackage {
-  override getAnyThreadTurboModuleFactoryByNameMap(): Map<
-    string,
-    (ctx: AnyThreadTurboModuleContext) => AnyThreadTurboModule | null
-  > {
-    return new Map<string, (ctx: AnyThreadTurboModuleContext) => AnyThreadTurboModule | null>()
-      .set(
-        ExpoHarmonyFileSystemTurboModule.NAME,
-        (ctx) => new ExpoHarmonyFileSystemTurboModule(ctx),
-      )
-      .set(
-        ExpoHarmonyLocationTurboModule.NAME,
-        (ctx) => new ExpoHarmonyLocationTurboModule(ctx),
-      );
-  }
-
-  override getUITurboModuleFactoryByNameMap(): Map<
-    string,
-    (ctx: UITurboModuleContext) => UITurboModule | null
-  > {
-    return new Map<string, (ctx: UITurboModuleContext) => UITurboModule | null>()
-      .set(
-        ExpoHarmonyImagePickerTurboModule.NAME,
-        (ctx) => new ExpoHarmonyImagePickerTurboModule(ctx),
-      )
-      .set(
-        ExpoHarmonyCameraTurboModule.NAME,
-        (ctx) => new ExpoHarmonyCameraTurboModule(ctx),
-      );
-  }
-
-  override getDebugName() {
-    return 'expo-harmony';
-  }
-}
-`;
-}
-function renderExpoHarmonyFileSystemTurboModule() {
-    return `import fs from '@ohos.file.fs';
-import { AnyThreadTurboModuleContext, AnyThreadTurboModule } from '@rnoh/react-native-openharmony/ts';
-
-type FileInfoOptions = {
-  md5?: boolean;
-};
-
-type WriteOptions = {
-  encoding?: string;
-  append?: boolean;
-};
-
-type ReadOptions = {
-  encoding?: string;
-  position?: number;
-  length?: number;
-};
-
-type MakeDirectoryOptions = {
-  intermediates?: boolean;
-};
-
-type DeleteOptions = {
-  idempotent?: boolean;
-};
-
-type FileInfoResult = {
-  exists: boolean;
-  path: string;
-  isDirectory: boolean;
-  size?: number;
-  modificationTime?: number;
-  md5?: string;
-};
-
-type DownloadOptions = {
-  headers?: Record<string, string>;
-  md5?: boolean;
-};
-
-type DownloadResult = {
-  uri: string;
-  status: number;
-  headers: Record<string, string>;
-  md5?: string;
-};
-
-export class ExpoHarmonyFileSystemTurboModule extends AnyThreadTurboModule {
-  public static readonly NAME = 'ExpoHarmonyFileSystem';
-
-  public constructor(ctx: AnyThreadTurboModuleContext) {
-    super(ctx);
-    this.ensureManagedDirectoriesSync();
-  }
-
-  getConstants(): {
-    documentDirectoryPath: string;
-    cacheDirectoryPath: string;
-    bundleDirectoryPath: string | null;
-  } {
-    const abilityContext = this.ctx.uiAbilityContext as {
-      bundleCodeDir?: string;
-    };
-
-    return {
-      documentDirectoryPath: this.documentDirectoryPath,
-      cacheDirectoryPath: this.cacheDirectoryPath,
-      bundleDirectoryPath:
-        typeof abilityContext.bundleCodeDir === 'string' && abilityContext.bundleCodeDir.length > 0
-          ? abilityContext.bundleCodeDir
-          : null,
-    };
-  }
-
-  async getInfo(path: string, options?: FileInfoOptions): Promise<FileInfoResult> {
-    const normalizedPath = this.normalizeSandboxPath(path);
-    const stat = await this.getStatOrNull(normalizedPath);
-
-    if (!stat) {
-      return {
-        exists: false,
-        path: normalizedPath,
-        isDirectory: false,
-      };
-    }
-
-    return {
-      exists: true,
-      path: normalizedPath,
-      isDirectory: stat.isDirectory(),
-      size: Number(stat.size),
-      modificationTime: Number(stat.mtime),
-      md5:
-        options?.md5 === true && !stat.isDirectory()
-          ? this.computePreviewDigest(await this.readFileBytes(normalizedPath))
-          : undefined,
-    };
-  }
-
-  async readAsString(path: string, options?: ReadOptions): Promise<string> {
-    const normalizedPath = this.normalizeSandboxPath(path);
-    const encoding = options?.encoding ?? 'utf8';
-    const bytes = await this.readFileBytes(normalizedPath);
-    const position = typeof options?.position === 'number' && options.position > 0
-      ? Math.floor(options.position)
-      : 0;
-    const length = typeof options?.length === 'number' && options.length >= 0
-      ? Math.floor(options.length)
-      : bytes.length - position;
-    const slicedBytes = bytes.slice(position, position + length);
-
-    if (encoding === 'base64') {
-      return this.encodeBase64(slicedBytes);
-    }
-
-    return this.decodeUtf8(slicedBytes);
-  }
-
-  async writeAsString(path: string, contents: string, options?: WriteOptions): Promise<void> {
-    const normalizedPath = this.normalizeSandboxPath(path);
-    const encoding = options?.encoding ?? 'utf8';
-
-    await this.ensureParentDirectory(normalizedPath);
-
-    const file = await fs.open(
-      normalizedPath,
-      fs.OpenMode.READ_WRITE |
-        fs.OpenMode.CREATE |
-        (options?.append === true ? fs.OpenMode.APPEND : fs.OpenMode.TRUNC),
-    );
-
-    try {
-      if (encoding === 'base64') {
-        await fs.write(file.fd, this.decodeBase64(contents).buffer);
-      } else {
-        await fs.write(file.fd, contents);
-      }
-    } finally {
-      await fs.close(file);
-    }
-  }
-
-  async deletePath(path: string, options?: DeleteOptions): Promise<void> {
-    const normalizedPath = this.normalizeSandboxPath(path);
-    await this.deleteInternal(normalizedPath, options?.idempotent === true);
-  }
-
-  async makeDirectory(path: string, options?: MakeDirectoryOptions): Promise<void> {
-    const normalizedPath = this.normalizeSandboxPath(path);
-    await fs.mkdir(normalizedPath, options?.intermediates === true);
-  }
-
-  async readDirectory(path: string): Promise<string[]> {
-    const normalizedPath = this.normalizeSandboxPath(path);
-    const stat = await fs.stat(normalizedPath);
-
-    if (!stat.isDirectory()) {
-      throw new Error('readDirectory expects a directory path.');
-    }
-
-    return fs.listFile(normalizedPath);
-  }
-
-  async copy(from: string, to: string): Promise<void> {
-    const fromPath = this.normalizeSandboxPath(from);
-    const toPath = this.normalizeSandboxPath(to);
-    await this.copyInternal(fromPath, toPath);
-  }
-
-  async move(from: string, to: string): Promise<void> {
-    const fromPath = this.normalizeSandboxPath(from);
-    const toPath = this.normalizeSandboxPath(to);
-    const stat = await fs.stat(fromPath);
-
-    await this.ensureParentDirectory(toPath);
-
-    if (stat.isDirectory()) {
-      await this.copyInternal(fromPath, toPath);
-      await this.deleteInternal(fromPath, false);
-      return;
-    }
-
-    await fs.moveFile(fromPath, toPath);
-  }
-
-  async download(url: string, destinationPath: string, options?: DownloadOptions): Promise<DownloadResult> {
-    const normalizedDestinationPath = this.normalizeSandboxPath(destinationPath);
-    await this.ensureParentDirectory(normalizedDestinationPath);
-
-    const response = await fetch(url, {
-      headers: options?.headers ?? {},
-    });
-    const responseBuffer = new Uint8Array(await response.arrayBuffer());
-    const file = await fs.open(
-      normalizedDestinationPath,
-      fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.TRUNC,
-    );
-
-    try {
-      await fs.write(file.fd, responseBuffer.buffer);
-    } finally {
-      await fs.close(file);
-    }
-
-    return {
-      uri: normalizedDestinationPath,
-      status: Number(response.status ?? 200),
-      headers: {},
-      md5: options?.md5 === true ? this.computePreviewDigest(responseBuffer) : undefined,
-    };
-  }
-
-  private get documentDirectoryPath(): string {
-    return \`\${this.ctx.uiAbilityContext.filesDir}/expo-harmony/document\`;
-  }
-
-  private get cacheDirectoryPath(): string {
-    return \`\${this.ctx.uiAbilityContext.cacheDir}/expo-harmony/cache\`;
-  }
-
-  private ensureManagedDirectoriesSync(): void {
-    this.ensureDirectorySync(this.documentDirectoryPath);
-    this.ensureDirectorySync(this.cacheDirectoryPath);
-  }
-
-  private ensureDirectorySync(directoryPath: string): void {
-    if (!fs.accessSync(directoryPath)) {
-      fs.mkdirSync(directoryPath, true);
-    }
-  }
-
-  private async ensureParentDirectory(targetPath: string): Promise<void> {
-    const parentPath = this.getParentPath(targetPath);
-
-    if (!parentPath) {
-      return;
-    }
-
-    const parentStat = await this.getStatOrNull(parentPath);
-
-    if (parentStat) {
-      if (!parentStat.isDirectory()) {
-        throw new Error(\`Expected parent path to be a directory: \${parentPath}\`);
-      }
-
-      return;
-    }
-
-    await fs.mkdir(parentPath, true);
-  }
-
-  private getParentPath(targetPath: string): string | null {
-    let normalizedPath = targetPath;
-
-    while (normalizedPath.length > 1 && normalizedPath.endsWith('/')) {
-      normalizedPath = normalizedPath.slice(0, -1);
-    }
-    const slashIndex = normalizedPath.lastIndexOf('/');
-
-    if (slashIndex <= 0) {
-      return null;
-    }
-
-    return normalizedPath.slice(0, slashIndex);
-  }
-
-  private async deleteInternal(targetPath: string, idempotent: boolean): Promise<void> {
-    const stat = await this.getStatOrNull(targetPath);
-
-    if (!stat) {
-      if (idempotent) {
-        return;
-      }
-
-      throw new Error(\`No file or directory exists at \${targetPath}.\`);
-    }
-
-    if (stat.isDirectory()) {
-      const entries = await fs.listFile(targetPath);
-
-      for (const entryName of entries) {
-        await this.deleteInternal(\`\${targetPath}/\${entryName}\`, idempotent);
-      }
-
-      await fs.rmdir(targetPath);
-      return;
-    }
-
-    await fs.unlink(targetPath);
-  }
-
-  private async copyInternal(fromPath: string, toPath: string): Promise<void> {
-    const stat = await fs.stat(fromPath);
-
-    await this.ensureParentDirectory(toPath);
-
-    if (stat.isDirectory()) {
-      await fs.mkdir(toPath, true);
-      const entries = await fs.listFile(fromPath);
-
-      for (const entryName of entries) {
-        await this.copyInternal(\`\${fromPath}/\${entryName}\`, \`\${toPath}/\${entryName}\`);
-      }
-
-      return;
-    }
-
-    await fs.copyFile(fromPath, toPath);
-  }
-
-  private async getStatOrNull(targetPath: string): Promise<fs.Stat | null> {
-    try {
-      return await fs.stat(targetPath);
-    } catch (error) {
-      if (this.isNoSuchFileError(error)) {
-        return null;
-      }
-
-      throw error;
-    }
-  }
-
-  private isNoSuchFileError(error: unknown): boolean {
-    return (
-      typeof error === 'object' &&
-      error !== null &&
-      'code' in error &&
-      Number((error as { code?: number }).code) === 13900002
-    );
-  }
-
-  private async readFileBytes(targetPath: string): Promise<Uint8Array> {
-    const stat = await fs.stat(targetPath);
-    const file = await fs.open(targetPath, fs.OpenMode.READ_ONLY);
-    const buffer = new ArrayBuffer(Number(stat.size ?? 0));
-
-    try {
-      await fs.read(file.fd, buffer);
-      return new Uint8Array(buffer);
-    } finally {
-      await fs.close(file);
-    }
-  }
-
-  private decodeUtf8(bytes: Uint8Array): string {
-    return new TextDecoder().decode(bytes);
-  }
-
-  private encodeBase64(bytes: Uint8Array): string {
-    let binary = '';
-
-    for (const byte of bytes) {
-      binary += String.fromCharCode(byte);
-    }
-
-    return btoa(binary);
-  }
-
-  private decodeBase64(contents: string): Uint8Array {
-    const binary = atob(contents);
-    const bytes = new Uint8Array(binary.length);
-
-    for (let index = 0; index < binary.length; index += 1) {
-      bytes[index] = binary.charCodeAt(index);
-    }
-
-    return bytes;
-  }
-
-  private computePreviewDigest(bytes: Uint8Array): string {
-    let hash = 2166136261;
-
-    for (const byte of bytes) {
-      hash ^= byte;
-      hash = Math.imul(hash, 16777619);
-    }
-
-    return String(hash >>> 0).padStart(32, '0').slice(-32);
-  }
-
-  private normalizeSandboxPath(inputPath: string): string {
-    if (typeof inputPath !== 'string' || inputPath.length === 0) {
-      throw new Error('ExpoHarmonyFileSystem expected a non-empty sandbox path.');
-    }
-
-    if (!inputPath.startsWith('/')) {
-      throw new Error('ExpoHarmonyFileSystem accepts only absolute sandbox paths.');
-    }
-
-    if (inputPath.includes('/../') || inputPath.endsWith('/..') || inputPath.includes('/./')) {
-      throw new Error('ExpoHarmonyFileSystem does not accept relative path segments.');
-    }
-
-    const allowedRoots = [
-      this.ctx.uiAbilityContext.filesDir,
-      this.ctx.uiAbilityContext.cacheDir,
-    ].filter((value): value is string => typeof value === 'string' && value.length > 0);
-
-    const isAllowed = allowedRoots.some(
-      (rootPath) => inputPath === rootPath || inputPath.startsWith(\`\${rootPath}/\`),
-    );
-
-    if (!isAllowed) {
-      throw new Error('ExpoHarmonyFileSystem accepts only app sandbox paths.');
-    }
-
-    return inputPath;
-  }
-}
-`;
-}
-function renderExpoHarmonyImagePickerTurboModule() {
-    return `import type { Permissions } from '@ohos.abilityAccessCtrl';
-import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
-import photoAccessHelper from '@ohos.file.photoAccessHelper';
-import picker from '@ohos.file.picker';
-import image from '@ohos.multimedia.image';
-import fs from '@ohos.file.fs';
-import { UITurboModuleContext, UITurboModule } from '@rnoh/react-native-openharmony/ts';
-
-type PermissionResponse = {
-  status: 'granted' | 'denied' | 'undetermined';
-  granted: boolean;
-  canAskAgain: boolean;
-  expires: 'never';
-  accessPrivileges?: 'all' | 'limited' | 'none';
-};
-
-type LaunchImageLibraryOptions = {
-  mediaTypes?: string | string[];
-  allowsMultipleSelection?: boolean;
-  selectionLimit?: number;
-};
-
-type LaunchCameraOptions = {
-  mediaTypes?: string | string[];
-  cameraType?: string;
-};
-
-type ImagePickerAsset = {
-  uri: string;
-  assetId: string | null;
-  width: number;
-  height: number;
-  type: 'image' | 'video' | null;
-  fileName: string | null;
-  fileSize: number | null;
-  mimeType: string | null;
-  duration: number | null;
-  exif: null;
-  base64: null;
-};
-
-type ImagePickerResult = {
-  canceled: boolean;
-  assets: ImagePickerAsset[] | null;
-};
-
-export class ExpoHarmonyImagePickerTurboModule extends UITurboModule {
-  public static readonly NAME = 'ExpoHarmonyImagePicker';
-
-  private readonly atManager = abilityAccessCtrl.createAtManager();
-  private pendingResult: ImagePickerResult | null = null;
-
-  getConstants(): Record<string, never> {
-    return {};
-  }
-
-  async getMediaLibraryPermissionStatus(_writeOnly?: boolean): Promise<PermissionResponse> {
-    return this.getPermissionResponse('ohos.permission.READ_IMAGEVIDEO', true);
-  }
-
-  async requestMediaLibraryPermission(_writeOnly?: boolean): Promise<PermissionResponse> {
-    return this.requestPermissionResponse('ohos.permission.READ_IMAGEVIDEO', true);
-  }
-
-  async getCameraPermissionStatus(): Promise<PermissionResponse> {
-    return this.getPermissionResponse('ohos.permission.CAMERA', false);
-  }
-
-  async requestCameraPermission(): Promise<PermissionResponse> {
-    return this.requestPermissionResponse('ohos.permission.CAMERA', false);
-  }
-
-  async launchImageLibrary(options?: LaunchImageLibraryOptions): Promise<ImagePickerResult> {
-    await this.ensurePermissionGranted('ohos.permission.READ_IMAGEVIDEO', true);
-
-    const photoPicker = new photoAccessHelper.PhotoViewPicker();
-    const selection = await photoPicker.select(this.createPhotoSelectOptions(options));
-    let selectedUris = this.normalizeSelectedUris(selection?.photoUris);
-
-    if (selectedUris.length === 0) {
-      selectedUris = await this.launchLegacyPhotoPicker(options);
-    }
-
-    if (selectedUris.length === 0) {
-      return this.createCanceledResult();
-    }
-
-    const authorizedUris = await this.requestAuthorizedUris(selectedUris);
-    const assets = await Promise.all(
-      authorizedUris.map((uri, index) =>
-        this.createImagePickerAsset(uri, selectedUris[index] ?? uri, this.inferAssetTypeFromMediaTypes(options?.mediaTypes)),
-      ),
-    );
-
-    const result = {
-      canceled: false,
-      assets,
-    };
-    this.pendingResult = result;
-    return result;
-  }
-
-  async launchCamera(options?: LaunchCameraOptions): Promise<ImagePickerResult> {
-    const requestedAssetType = this.inferAssetTypeFromMediaTypes(options?.mediaTypes);
-
-    await this.ensurePermissionGranted('ohos.permission.CAMERA', false);
-    await this.ensurePermissionGranted('ohos.permission.READ_IMAGEVIDEO', true);
-    if (requestedAssetType === 'video') {
-      await this.ensurePermissionGranted('ohos.permission.MICROPHONE', false);
-    }
-
-    const cameraEntryPicker = new photoAccessHelper.PhotoViewPicker();
-    const selection = await cameraEntryPicker.select(
-      this.createPhotoSelectOptions(
-        {
-          mediaTypes: requestedAssetType === 'video' ? 'videos' : 'images',
-          allowsMultipleSelection: false,
-        },
-        true,
-      ),
-    );
-    const selectedUris = this.normalizeSelectedUris(selection?.photoUris);
-
-    if (selectedUris.length === 0) {
-      return this.createCanceledResult();
-    }
-
-    const authorizedUris = await this.requestAuthorizedUris(selectedUris);
-    const assetUri = authorizedUris[0] ?? selectedUris[0];
-
-    const result = {
-      canceled: false,
-      assets: [await this.createImagePickerAsset(assetUri, selectedUris[0], requestedAssetType ?? 'image')],
-    };
-    this.pendingResult = result;
-    return result;
-  }
-
-  async getPendingResult(): Promise<ImagePickerResult | null> {
-    const result = this.pendingResult;
-    this.pendingResult = null;
-    return result;
-  }
-
-  private async ensurePermissionGranted(
-    permissionName: Permissions,
-    isMediaLibraryPermission: boolean,
-  ): Promise<void> {
-    const permissionResponse = await this.getPermissionResponse(permissionName, isMediaLibraryPermission);
-
-    if (permissionResponse.granted) {
-      return;
-    }
-
-    const requestedResponse = await this.requestPermissionResponse(permissionName, isMediaLibraryPermission);
-
-    if (!requestedResponse.granted) {
-      throw new Error(\`Permission denied for \${permissionName}.\`);
-    }
-  }
-
-  private async getPermissionResponse(
-    permissionName: Permissions,
-    isMediaLibraryPermission: boolean,
-  ): Promise<PermissionResponse> {
-    return this.permissionResponseFromStatus(
-      this.resolvePermissionStatus(permissionName),
-      isMediaLibraryPermission,
-    );
-  }
-
-  private async requestPermissionResponse(
-    permissionName: Permissions,
-    isMediaLibraryPermission: boolean,
-  ): Promise<PermissionResponse> {
-    const requestResult = await this.atManager.requestPermissionsFromUser(
-      this.ctx.uiAbilityContext,
-      [permissionName],
-    );
-    const authResult = Array.isArray(requestResult.authResults)
-      ? Number(requestResult.authResults[0] ?? abilityAccessCtrl.GrantStatus.PERMISSION_DENIED)
-      : abilityAccessCtrl.GrantStatus.PERMISSION_DENIED;
-
-    if (authResult === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
-      return this.permissionResponseFromStatus(
-        abilityAccessCtrl.PermissionStatus.GRANTED,
-        isMediaLibraryPermission,
-      );
-    }
-
-    return this.permissionResponseFromStatus(
-      abilityAccessCtrl.PermissionStatus.DENIED,
-      isMediaLibraryPermission,
-    );
-  }
-
-  private resolvePermissionStatus(permissionName: Permissions): abilityAccessCtrl.PermissionStatus {
-    const atManagerWithSelfStatus = this.atManager as abilityAccessCtrl.AtManager & {
-      getSelfPermissionStatus?: (permission: Permissions) => abilityAccessCtrl.PermissionStatus;
-    };
-
-    if (typeof atManagerWithSelfStatus.getSelfPermissionStatus === 'function') {
-      return atManagerWithSelfStatus.getSelfPermissionStatus(permissionName);
-    }
-
-    const accessTokenId = this.ctx.uiAbilityContext.abilityInfo.applicationInfo.accessTokenId;
-    const grantStatus = this.atManager.checkAccessTokenSync(accessTokenId, permissionName);
-
-    return grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED
-      ? abilityAccessCtrl.PermissionStatus.GRANTED
-      : abilityAccessCtrl.PermissionStatus.NOT_DETERMINED;
-  }
-
-  private permissionResponseFromStatus(
-    permissionStatus: abilityAccessCtrl.PermissionStatus,
-    isMediaLibraryPermission: boolean,
-  ): PermissionResponse {
-    const granted = permissionStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
-    const denied =
-      permissionStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
-      permissionStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
-      permissionStatus === abilityAccessCtrl.PermissionStatus.INVALID;
-
-    return {
-      status: granted ? 'granted' : denied ? 'denied' : 'undetermined',
-      granted,
-      canAskAgain: !denied,
-      expires: 'never',
-      ...(isMediaLibraryPermission
-        ? {
-            accessPrivileges: granted ? 'all' : 'none',
-          }
-        : {}),
-    };
-  }
-
-  private createPhotoSelectOptions(
-    options?: LaunchImageLibraryOptions,
-    isPhotoTakingSupported: boolean = false,
-  ): photoAccessHelper.PhotoSelectOptions {
-    const selectOptions = new photoAccessHelper.PhotoSelectOptions();
-    selectOptions.MIMEType = this.resolvePhotoViewMimeType(options?.mediaTypes);
-    selectOptions.maxSelectNumber =
-      options?.allowsMultipleSelection === true
-        ? this.resolveSelectionLimit(options?.selectionLimit)
-        : 1;
-    selectOptions.isSearchSupported = true;
-    selectOptions.isPhotoTakingSupported = isPhotoTakingSupported;
-    return selectOptions;
-  }
-
-  private async launchLegacyPhotoPicker(options?: LaunchImageLibraryOptions): Promise<string[]> {
-    const legacyPicker = new picker.PhotoViewPicker(this.ctx.uiAbilityContext);
-    const legacyOptions = new picker.PhotoSelectOptions();
-    legacyOptions.MIMEType = this.resolveLegacyPhotoViewMimeType(options?.mediaTypes);
-    legacyOptions.maxSelectNumber =
-      options?.allowsMultipleSelection === true
-        ? this.resolveSelectionLimit(options?.selectionLimit)
-        : 1;
-
-    const selection = await legacyPicker.select(legacyOptions);
-    return this.normalizeSelectedUris(selection?.photoUris);
-  }
-
-  private resolveSelectionLimit(selectionLimit?: number): number {
-    if (typeof selectionLimit === 'number' && Number.isFinite(selectionLimit) && selectionLimit > 0) {
-      return Math.floor(selectionLimit);
-    }
-
-    return 20;
-  }
-
-  private resolvePhotoViewMimeType(
-    rawMediaTypes?: string | string[],
-  ): photoAccessHelper.PhotoViewMIMETypes {
-    const normalized = this.normalizeMediaTypes(rawMediaTypes);
-
-    if (normalized.includes('video') && !normalized.includes('image')) {
-      return photoAccessHelper.PhotoViewMIMETypes.VIDEO_TYPE;
-    }
-
-    if (normalized.includes('video') && normalized.includes('image')) {
-      return photoAccessHelper.PhotoViewMIMETypes.IMAGE_VIDEO_TYPE;
-    }
-
-    return photoAccessHelper.PhotoViewMIMETypes.IMAGE_TYPE;
-  }
-
-  private resolveLegacyPhotoViewMimeType(
-    rawMediaTypes?: string | string[],
-  ): picker.PhotoViewMIMETypes {
-    const normalized = this.normalizeMediaTypes(rawMediaTypes);
-
-    if (normalized.includes('video') && !normalized.includes('image')) {
-      return picker.PhotoViewMIMETypes.VIDEO_TYPE;
-    }
-
-    if (normalized.includes('video') && normalized.includes('image')) {
-      return picker.PhotoViewMIMETypes.IMAGE_VIDEO_TYPE;
-    }
-
-    return picker.PhotoViewMIMETypes.IMAGE_TYPE;
-  }
-
-  private inferAssetTypeFromMediaTypes(
-    rawMediaTypes?: string | string[],
-  ): 'image' | 'video' | null {
-    const normalized = this.normalizeMediaTypes(rawMediaTypes);
-
-    if (normalized.includes('video') && !normalized.includes('image')) {
-      return 'video';
-    }
-
-    if (normalized.includes('image')) {
-      return 'image';
-    }
-
-    return null;
-  }
-
-  private normalizeMediaTypes(rawMediaTypes?: string | string[]): string[] {
-    if (Array.isArray(rawMediaTypes)) {
-      return Array.from(
-        new Set(
-          rawMediaTypes
-            .map((value) => this.normalizeMediaTypeValue(value))
-            .filter((value): value is string => value !== null),
-        ),
-      );
-    }
-
-    const singleValue = this.normalizeMediaTypeValue(rawMediaTypes);
-    return singleValue ? [singleValue] : ['image'];
-  }
-
-  private normalizeMediaTypeValue(rawValue?: string): string | null {
-    if (typeof rawValue !== 'string' || rawValue.length === 0) {
-      return 'image';
-    }
-
-    switch (rawValue) {
-      case 'All':
-      case 'all':
-      case 'images':
-      case 'image':
-      case 'livePhotos':
-        return 'image';
-      case 'Videos':
-      case 'videos':
-      case 'video':
-        return 'video';
-      default:
-        return rawValue.includes('video') ? 'video' : rawValue.includes('image') ? 'image' : null;
-    }
-  }
-
-  private normalizeSelectedUris(photoUris: Array<string> | undefined | null): string[] {
-    if (!Array.isArray(photoUris)) {
-      return [];
-    }
-
-    return photoUris.filter(
-      (value): value is string => typeof value === 'string' && value.length > 0,
-    );
-  }
-
-  private async requestAuthorizedUris(photoUris: string[]): Promise<string[]> {
-    const helper = photoAccessHelper.getPhotoAccessHelper(this.ctx.uiAbilityContext);
-
-    try {
-      const authorizedUris = await helper.requestPhotoUrisReadPermission(photoUris);
-      const normalizedAuthorizedUris = this.normalizeSelectedUris(authorizedUris);
-      return normalizedAuthorizedUris.length > 0 ? normalizedAuthorizedUris : photoUris;
-    } catch (_error) {
-      return photoUris;
-    }
-  }
-
-  private async createImagePickerAsset(
-    assetUri: string,
-    originalUri: string,
-    fallbackType: 'image' | 'video' | null,
-  ): Promise<ImagePickerAsset> {
-    const inferredType = this.inferAssetTypeFromUri(assetUri, fallbackType);
-    const imageSize =
-      inferredType === 'image' ? await this.getImageSize(assetUri) : { width: 0, height: 0 };
-    const fileSize = await this.getFileSize(assetUri);
-    const fileName = this.extractFileName(assetUri) ?? this.extractFileName(originalUri);
-
-    return {
-      uri: assetUri,
-      assetId: originalUri,
-      width: imageSize.width,
-      height: imageSize.height,
-      type: inferredType,
-      fileName,
-      fileSize,
-      mimeType: this.inferMimeType(assetUri, inferredType),
-      duration: inferredType === 'video' ? await this.getVideoDuration(assetUri) : null,
-      exif: null,
-      base64: null,
-    };
-  }
-
-  private inferAssetTypeFromUri(
-    assetUri: string,
-    fallbackType: 'image' | 'video' | null,
-  ): 'image' | 'video' | null {
-    const normalizedUri = assetUri.toLowerCase();
-
-    if (normalizedUri.match(/\\.(mp4|m4v|mov|3gp|webm)(\\?|#|$)/)) {
-      return 'video';
-    }
-
-    if (normalizedUri.match(/\\.(png|jpe?g|gif|bmp|webp|heic|heif)(\\?|#|$)/)) {
-      return 'image';
-    }
-
-    return fallbackType;
-  }
-
-  private inferMimeType(
-    assetUri: string,
-    assetType: 'image' | 'video' | null,
-  ): string | null {
-    const normalizedUri = assetUri.toLowerCase();
-
-    if (normalizedUri.endsWith('.png')) {
-      return 'image/png';
-    }
-    if (normalizedUri.endsWith('.gif')) {
-      return 'image/gif';
-    }
-    if (normalizedUri.endsWith('.webp')) {
-      return 'image/webp';
-    }
-    if (normalizedUri.endsWith('.bmp')) {
-      return 'image/bmp';
-    }
-    if (normalizedUri.endsWith('.heic')) {
-      return 'image/heic';
-    }
-    if (normalizedUri.endsWith('.heif')) {
-      return 'image/heif';
-    }
-    if (normalizedUri.match(/\\.jpe?g(\\?|#|$)/)) {
-      return 'image/jpeg';
-    }
-    if (normalizedUri.match(/\\.(mp4|m4v)(\\?|#|$)/)) {
-      return 'video/mp4';
-    }
-    if (normalizedUri.match(/\\.mov(\\?|#|$)/)) {
-      return 'video/quicktime';
-    }
-    if (normalizedUri.match(/\\.webm(\\?|#|$)/)) {
-      return 'video/webm';
-    }
-
-    return assetType === 'video' ? 'video/*' : assetType === 'image' ? 'image/*' : null;
-  }
-
-  private extractFileName(assetUri: string): string | null {
-    if (typeof assetUri !== 'string' || assetUri.length === 0) {
-      return null;
-    }
-
-    const sanitizedUri = assetUri.split('?')[0]?.split('#')[0] ?? assetUri;
-    const lastSlashIndex = sanitizedUri.lastIndexOf('/');
-    const rawFileName =
-      lastSlashIndex >= 0 ? sanitizedUri.slice(lastSlashIndex + 1) : sanitizedUri;
-
-    if (rawFileName.length === 0) {
-      return null;
-    }
-
-    try {
-      return decodeURIComponent(rawFileName);
-    } catch (_error) {
-      return rawFileName;
-    }
-  }
-
-  private async getImageSize(assetUri: string): Promise<{ width: number; height: number }> {
-    let imageSource: image.ImageSource | null = null;
-
-    try {
-      imageSource = image.createImageSource(assetUri);
-      const imageInfo = await imageSource.getImageInfo();
-      return {
-        width: Number(imageInfo.size?.width ?? 0),
-        height: Number(imageInfo.size?.height ?? 0),
-      };
-    } catch (_error) {
-      return {
-        width: 0,
-        height: 0,
-      };
-    } finally {
-      if (imageSource) {
-        try {
-          await imageSource.release();
-        } catch (_error) {
-          // Ignore cleanup errors from ImageSource release.
-        }
-      }
-    }
-  }
-
-  private async getFileSize(assetUri: string): Promise<number | null> {
-    const fsTarget = this.resolveFsTarget(assetUri);
-
-    if (!fsTarget) {
-      return null;
-    }
-
-    try {
-      const stat = await fs.stat(fsTarget);
-      return Number(stat.size ?? 0);
-    } catch (_error) {
-      return null;
-    }
-  }
-
-  private async getVideoDuration(_assetUri: string): Promise<number | null> {
-    return 0;
-  }
-
-  private resolveFsTarget(assetUri: string): string | null {
-    if (assetUri.startsWith('file://')) {
-      return assetUri.slice('file://'.length);
-    }
-
-    return assetUri.startsWith('/') ? assetUri : null;
-  }
-
-  private createCanceledResult(): ImagePickerResult {
-    return {
-      canceled: true,
-      assets: null,
-    };
-  }
-}
-`;
-}
-function renderExpoHarmonyLocationTurboModule() {
-    return `import type { Permissions } from '@ohos.abilityAccessCtrl';
-import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
-import geoLocationManager from '@ohos.geoLocationManager';
-import { sensor } from '@kit.SensorServiceKit';
-import { AnyThreadTurboModuleContext, AnyThreadTurboModule } from '@rnoh/react-native-openharmony/ts';
-
-type PermissionResponse = {
-  status: 'granted' | 'denied' | 'undetermined';
-  granted: boolean;
-  canAskAgain: boolean;
-  expires: 'never';
-  android: {
-    accuracy: 'fine' | 'coarse' | 'none';
-  };
-};
-
-type ExpoLocationObject = {
-  coords: {
-    latitude: number;
-    longitude: number;
-    altitude: number | null;
-    accuracy: number | null;
-    altitudeAccuracy: number | null;
-    heading: number | null;
-    speed: number | null;
-  };
-  timestamp: number;
-  mocked: false;
-};
-
-type ProviderStatus = {
-  locationServicesEnabled: boolean;
-  backgroundModeEnabled: boolean;
-  gpsAvailable: boolean;
-  networkAvailable: boolean;
-  passiveAvailable: boolean;
-};
-
-type ReverseGeocodeResult = {
-  city: string | null;
-  district: string | null;
-  streetNumber: string | null;
-  street: string | null;
-  region: string | null;
-  subregion: string | null;
-  country: string | null;
-  postalCode: string | null;
-  name: string | null;
-  isoCountryCode: string | null;
-  timezone: null;
-  formattedAddress: string | null;
-};
-
-type GeocodeResult = {
-  latitude: number;
-  longitude: number;
-  altitude?: number;
-  accuracy?: number;
-};
-
-type HeadingObject = {
-  magHeading: number;
-  trueHeading: number | null;
-  accuracy: number;
-};
-
-export class ExpoHarmonyLocationTurboModule extends AnyThreadTurboModule {
-  public static readonly NAME = 'ExpoHarmonyLocation';
-
-  private readonly atManager = abilityAccessCtrl.createAtManager();
-  private nextWatchId = 1;
-
-  getConstants(): Record<string, never> {
-    return {};
-  }
-
-  async getForegroundPermissionStatus(): Promise<PermissionResponse> {
-    return this.getLocationPermissionResponse();
-  }
-
-  async requestForegroundPermission(): Promise<PermissionResponse> {
-    return this.requestLocationPermissionResponse();
-  }
-
-  async getBackgroundPermissionStatus(): Promise<PermissionResponse> {
-    const backgroundStatus = this.resolvePermissionStatus('ohos.permission.LOCATION_IN_BACKGROUND');
-    return this.buildBackgroundPermissionResponse(backgroundStatus);
-  }
-
-  async requestBackgroundPermission(): Promise<PermissionResponse> {
-    await this.atManager.requestPermissionsFromUser(this.ctx.uiAbilityContext, [
-      'ohos.permission.LOCATION_IN_BACKGROUND',
-    ]);
-    return this.getBackgroundPermissionStatus();
-  }
-
-  async hasServicesEnabled(): Promise<boolean> {
-    return geoLocationManager.isLocationEnabled();
-  }
-
-  async getProviderStatus(): Promise<ProviderStatus> {
-    const locationServicesEnabled = geoLocationManager.isLocationEnabled();
-
-    return {
-      locationServicesEnabled,
-      backgroundModeEnabled:
-        this.resolvePermissionStatus('ohos.permission.LOCATION_IN_BACKGROUND') ===
-        abilityAccessCtrl.PermissionStatus.GRANTED,
-      gpsAvailable: locationServicesEnabled,
-      networkAvailable: locationServicesEnabled,
-      passiveAvailable: locationServicesEnabled,
-    };
-  }
-
-  async getCurrentPosition(options?: { accuracy?: number }): Promise<ExpoLocationObject> {
-    const location = await geoLocationManager.getCurrentLocation(
-      this.createCurrentLocationRequest(options?.accuracy),
-    );
-    return this.normalizeLocation(location);
-  }
-
-  async getLastKnownPosition(_options?: Record<string, unknown>): Promise<ExpoLocationObject | null> {
-    try {
-      const location = geoLocationManager.getLastLocation();
-      return this.hasCoordinates(location) ? this.normalizeLocation(location) : null;
-    } catch (_error) {
-      return null;
-    }
-  }
-
-  async geocode(address: string): Promise<GeocodeResult[]> {
-    const addresses = await geoLocationManager.getAddressesFromLocationName({
-      description: address,
-      locale: 'en-US',
-      maxItems: 5,
-    });
-
-    return addresses.map((addressEntry) => ({
-      latitude: Number(addressEntry.latitude ?? 0),
-      longitude: Number(addressEntry.longitude ?? 0),
-    }));
-  }
-
-  async reverseGeocode(location: { latitude: number; longitude: number }): Promise<ReverseGeocodeResult[]> {
-    const addresses = await geoLocationManager.getAddressesFromLocation({
-      latitude: Number(location.latitude),
-      longitude: Number(location.longitude),
-      locale: 'en-US',
-      maxItems: 5,
-    });
-
-    return addresses.map((addressEntry) => ({
-      city: addressEntry.locality ?? null,
-      district: addressEntry.subLocality ?? null,
-      streetNumber: addressEntry.subThoroughfare ?? null,
-      street: addressEntry.thoroughfare ?? null,
-      region: addressEntry.administrativeArea ?? null,
-      subregion: addressEntry.subAdministrativeArea ?? null,
-      country: addressEntry.countryName ?? null,
-      postalCode: addressEntry.postalCode ?? null,
-      name: addressEntry.placeName ?? null,
-      isoCountryCode: addressEntry.countryCode ?? null,
-      timezone: null,
-      formattedAddress:
-        addressEntry.addressUrl ??
-        (Array.isArray(addressEntry.descriptions) && addressEntry.descriptions.length > 0
-          ? addressEntry.descriptions.join(', ')
-          : null),
-    }));
-  }
-
-  async startWatchPosition(
-    options?: { accuracy?: number },
-    _listenerConfig?: Record<string, unknown>,
-  ): Promise<{ watchId: number; initialLocation: ExpoLocationObject | null }> {
-    const watchId = this.nextWatchId++;
-    return {
-      watchId,
-      initialLocation: await this.getLastKnownPosition(options ?? {}),
-    };
-  }
-
-  async stopWatchPosition(_watchId: number): Promise<void> {
-    return;
-  }
-
-  async getHeading(): Promise<HeadingObject> {
-    return this.readHeadingSnapshot();
-  }
-
-  async startWatchHeading(
-    _listenerConfig?: Record<string, unknown>,
-  ): Promise<{ watchId: number; initialHeading: HeadingObject }> {
-    const watchId = this.nextWatchId++;
-    return {
-      watchId,
-      initialHeading: await this.getHeading(),
-    };
-  }
-
-  async stopWatchHeading(_watchId: number): Promise<void> {
-    return;
-  }
-
-  private async getLocationPermissionResponse(): Promise<PermissionResponse> {
-    const approximateStatus = this.resolvePermissionStatus('ohos.permission.APPROXIMATELY_LOCATION');
-    const preciseStatus = this.resolvePermissionStatus('ohos.permission.LOCATION');
-
-    return this.buildPermissionResponse(approximateStatus, preciseStatus);
-  }
-
-  private buildBackgroundPermissionResponse(
-    backgroundStatus: abilityAccessCtrl.PermissionStatus,
-  ): PermissionResponse {
-    const foreground = this.getLocationPermissionResponse();
-    const granted = backgroundStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
-    const denied =
-      backgroundStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
-      backgroundStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
-      backgroundStatus === abilityAccessCtrl.PermissionStatus.INVALID;
-
-    return foreground.then((foregroundPermission) => ({
-      ...foregroundPermission,
-      status: granted ? 'granted' : denied ? 'denied' : 'undetermined',
-      granted,
-      canAskAgain: !denied,
-    }));
-  }
-
-  private async requestLocationPermissionResponse(): Promise<PermissionResponse> {
-    await this.atManager.requestPermissionsFromUser(this.ctx.uiAbilityContext, [
-      'ohos.permission.APPROXIMATELY_LOCATION',
-      'ohos.permission.LOCATION',
-    ]);
-
-    return this.getLocationPermissionResponse();
-  }
-
-  private resolvePermissionStatus(permissionName: Permissions): abilityAccessCtrl.PermissionStatus {
-    const atManagerWithSelfStatus = this.atManager as abilityAccessCtrl.AtManager & {
-      getSelfPermissionStatus?: (permission: Permissions) => abilityAccessCtrl.PermissionStatus;
-    };
-
-    if (typeof atManagerWithSelfStatus.getSelfPermissionStatus === 'function') {
-      return atManagerWithSelfStatus.getSelfPermissionStatus(permissionName);
-    }
-
-    const accessTokenId = this.ctx.uiAbilityContext.abilityInfo.applicationInfo.accessTokenId;
-    const grantStatus = this.atManager.checkAccessTokenSync(accessTokenId, permissionName);
-
-    return grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED
-      ? abilityAccessCtrl.PermissionStatus.GRANTED
-      : abilityAccessCtrl.PermissionStatus.NOT_DETERMINED;
-  }
-
-  private buildPermissionResponse(
-    approximateStatus: abilityAccessCtrl.PermissionStatus,
-    preciseStatus: abilityAccessCtrl.PermissionStatus,
-  ): PermissionResponse {
-    const coarseGranted = approximateStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
-    const fineGranted = preciseStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
-    const granted = coarseGranted || fineGranted;
-    const denied =
-      (approximateStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
-        approximateStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
-        approximateStatus === abilityAccessCtrl.PermissionStatus.INVALID) &&
-      (preciseStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
-        preciseStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
-        preciseStatus === abilityAccessCtrl.PermissionStatus.INVALID);
-
-    return {
-      status: granted ? 'granted' : denied ? 'denied' : 'undetermined',
-      granted,
-      canAskAgain: !denied,
-      expires: 'never',
-      android: {
-        accuracy: fineGranted ? 'fine' : coarseGranted ? 'coarse' : 'none',
-      },
-    };
-  }
-
-  private createCurrentLocationRequest(accuracy?: number): geoLocationManager.CurrentLocationRequest {
-    if (typeof accuracy === 'number' && accuracy >= 4) {
-      return {
-        priority: geoLocationManager.LocationRequestPriority.ACCURACY,
-      };
-    }
-
-    if (typeof accuracy === 'number' && accuracy <= 2) {
-      return {
-        priority: geoLocationManager.LocationRequestPriority.LOW_POWER,
-      };
-    }
-
-    return {
-      priority: geoLocationManager.LocationRequestPriority.FIRST_FIX,
-    };
-  }
-
-  private hasCoordinates(location: geoLocationManager.Location | null | undefined): location is geoLocationManager.Location {
-    return (
-      !!location &&
-      typeof location.latitude === 'number' &&
-      typeof location.longitude === 'number'
-    );
-  }
-
-  private normalizeLocation(location: geoLocationManager.Location): ExpoLocationObject {
-    return {
-      coords: {
-        latitude: Number(location.latitude),
-        longitude: Number(location.longitude),
-        altitude: typeof location.altitude === 'number' ? location.altitude : null,
-        accuracy: typeof location.accuracy === 'number' ? location.accuracy : null,
-        altitudeAccuracy: null,
-        heading: typeof location.direction === 'number' ? location.direction : null,
-        speed: typeof location.speed === 'number' ? location.speed : null,
-      },
-      timestamp: Number(location.timeStamp ?? Date.now()),
-      mocked: false,
-    };
-  }
-
-  private async readHeadingSnapshot(): Promise<HeadingObject> {
-    return new Promise((resolve) => {
-      try {
-        sensor.once(sensor.SensorId.ROTATION_VECTOR, (data: Record<string, number>) => {
-          const x = Number(data?.x ?? 0);
-          const y = Number(data?.y ?? 0);
-          const z = Number(data?.z ?? 0);
-          const w = Number(data?.w ?? 1);
-          const sinyCosp = 2 * (w * z + x * y);
-          const cosyCosp = 1 - 2 * (y * y + z * z);
-          const magHeading = (Math.atan2(sinyCosp, cosyCosp) * 180 / Math.PI + 360) % 360;
-          resolve({
-            magHeading,
-            trueHeading: magHeading,
-            accuracy: 3,
-          });
-        });
-      } catch (_error) {
-        resolve({
-          magHeading: 0,
-          trueHeading: null,
-          accuracy: 0,
-        });
-      }
-    });
-  }
-}
-`;
-}
-function renderExpoHarmonyCameraTurboModule() {
-    return `import type { Permissions } from '@ohos.abilityAccessCtrl';
-import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
-import camera from '@ohos.multimedia.camera';
-import cameraPicker from '@ohos.multimedia.cameraPicker';
-import image from '@ohos.multimedia.image';
-import { UITurboModuleContext, UITurboModule } from '@rnoh/react-native-openharmony/ts';
-
-type PermissionResponse = {
-  status: 'granted' | 'denied' | 'undetermined';
-  granted: boolean;
-  canAskAgain: boolean;
-  expires: 'never';
-};
-
-type CameraCaptureResult = {
-  uri: string;
-  width: number;
-  height: number;
-  base64?: string;
-  exif: null;
-};
-
-type CameraRecordingResult = {
-  uri: string;
-  duration: number;
-  fileSize: number | null;
-  mimeType: string;
-};
-
-export class ExpoHarmonyCameraTurboModule extends UITurboModule {
-  public static readonly NAME = 'ExpoHarmonyCamera';
-
-  private readonly atManager = abilityAccessCtrl.createAtManager();
-  private readonly previewStates = new Map<string, 'running' | 'paused'>();
-  private readonly activeRecordings = new Map<string, CameraRecordingResult>();
-
-  getConstants(): Record<string, never> {
-    return {};
-  }
-
-  async getCameraPermissionStatus(): Promise<PermissionResponse> {
-    return this.getPermissionResponse('ohos.permission.CAMERA');
-  }
-
-  async requestCameraPermission(): Promise<PermissionResponse> {
-    return this.requestPermissionResponse('ohos.permission.CAMERA');
-  }
-
-  async getMicrophonePermissionStatus(): Promise<PermissionResponse> {
-    return this.getPermissionResponse('ohos.permission.MICROPHONE');
-  }
-
-  async requestMicrophonePermission(): Promise<PermissionResponse> {
-    return this.requestPermissionResponse('ohos.permission.MICROPHONE');
-  }
-
-  async createPreview(options?: { viewId?: string }): Promise<{ viewId: string; state: 'running' }> {
-    const viewId = typeof options?.viewId === 'string' && options.viewId.length > 0
-      ? options.viewId
-      : 'expo-harmony-camera-preview';
-    this.previewStates.set(viewId, 'running');
-    return {
-      viewId,
-      state: 'running',
-    };
-  }
-
-  async disposePreview(options?: { viewId?: string }): Promise<void> {
-    if (typeof options?.viewId === 'string') {
-      this.previewStates.delete(options.viewId);
-      this.activeRecordings.delete(options.viewId);
-    }
-  }
-
-  async pausePreview(options?: { viewId?: string }): Promise<{ paused: boolean }> {
-    if (typeof options?.viewId === 'string') {
-      this.previewStates.set(options.viewId, 'paused');
-    }
-    return {
-      paused: true,
-    };
-  }
-
-  async resumePreview(options?: { viewId?: string }): Promise<{ paused: boolean }> {
-    if (typeof options?.viewId === 'string') {
-      this.previewStates.set(options.viewId, 'running');
-    }
-    return {
-      paused: false,
-    };
-  }
-
-  async takePicture(options?: { cameraType?: string; viewId?: string }): Promise<CameraCaptureResult> {
-    const profile = new cameraPicker.PickerProfile();
-    profile.cameraPosition =
-      options?.cameraType === 'front'
-        ? camera.CameraPosition.CAMERA_POSITION_FRONT
-        : camera.CameraPosition.CAMERA_POSITION_BACK;
-
-    const result = await cameraPicker.pick(
-      this.ctx.uiAbilityContext,
-      [cameraPicker.PickerMediaType.PHOTO],
-      profile,
-    );
-
-    if (!result || typeof result.resultUri !== 'string' || result.resultUri.length === 0) {
-      throw new Error('Camera capture was canceled.');
-    }
-
-    const imageSize = await this.getImageSize(result.resultUri);
-
-    return {
-      uri: result.resultUri,
-      width: imageSize.width,
-      height: imageSize.height,
-      exif: null,
-    };
-  }
-
-  async startRecording(options?: { viewId?: string; cameraType?: string }): Promise<CameraRecordingResult> {
-    await this.requestPermissionResponse('ohos.permission.MICROPHONE');
-    const profile = new cameraPicker.PickerProfile();
-    profile.cameraPosition =
-      options?.cameraType === 'front'
-        ? camera.CameraPosition.CAMERA_POSITION_FRONT
-        : camera.CameraPosition.CAMERA_POSITION_BACK;
-
-    const result = await cameraPicker.pick(
-      this.ctx.uiAbilityContext,
-      [cameraPicker.PickerMediaType.VIDEO],
-      profile,
-    );
-
-    if (!result || typeof result.resultUri !== 'string' || result.resultUri.length === 0) {
-      throw new Error('Camera recording was canceled.');
-    }
-
-    const recording = {
-      uri: result.resultUri,
-      duration: 0,
-      fileSize: null,
-      mimeType: 'video/mp4',
-    };
-
-    if (typeof options?.viewId === 'string') {
-      this.activeRecordings.set(options.viewId, recording);
-    }
-
-    return recording;
-  }
-
-  async stopRecording(options?: { viewId?: string }): Promise<CameraRecordingResult | null> {
-    if (typeof options?.viewId === 'string') {
-      const recording = this.activeRecordings.get(options.viewId) ?? null;
-      this.activeRecordings.delete(options.viewId);
-      return recording;
-    }
-
-    return null;
-  }
-
-  async toggleRecording(options?: { viewId?: string; cameraType?: string }): Promise<CameraRecordingResult | null> {
-    if (typeof options?.viewId === 'string' && this.activeRecordings.has(options.viewId)) {
-      return this.stopRecording(options);
-    }
-
-    return this.startRecording(options);
-  }
-
-  private async getPermissionResponse(permissionName: Permissions): Promise<PermissionResponse> {
-    const atManagerWithSelfStatus = this.atManager as abilityAccessCtrl.AtManager & {
-      getSelfPermissionStatus?: (permission: Permissions) => abilityAccessCtrl.PermissionStatus;
-    };
-    const permissionStatus =
-      typeof atManagerWithSelfStatus.getSelfPermissionStatus === 'function'
-        ? atManagerWithSelfStatus.getSelfPermissionStatus(permissionName)
-        : this.atManager.checkAccessTokenSync(
-            this.ctx.uiAbilityContext.abilityInfo.applicationInfo.accessTokenId,
-            permissionName,
-          ) === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED
-          ? abilityAccessCtrl.PermissionStatus.GRANTED
-          : abilityAccessCtrl.PermissionStatus.NOT_DETERMINED;
-
-    return this.createPermissionResponse(permissionStatus);
-  }
-
-  private async requestPermissionResponse(permissionName: Permissions): Promise<PermissionResponse> {
-    await this.atManager.requestPermissionsFromUser(this.ctx.uiAbilityContext, [permissionName]);
-    return this.getPermissionResponse(permissionName);
-  }
-
-  private createPermissionResponse(
-    permissionStatus: abilityAccessCtrl.PermissionStatus,
-  ): PermissionResponse {
-    const granted = permissionStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
-    const denied =
-      permissionStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
-      permissionStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
-      permissionStatus === abilityAccessCtrl.PermissionStatus.INVALID;
-
-    return {
-      status: granted ? 'granted' : denied ? 'denied' : 'undetermined',
-      granted,
-      canAskAgain: !denied,
-      expires: 'never',
-    };
-  }
-
-  private async getImageSize(assetUri: string): Promise<{ width: number; height: number }> {
-    let imageSource: image.ImageSource | null = null;
-
-    try {
-      imageSource = image.createImageSource(assetUri);
-      const imageInfo = await imageSource.getImageInfo();
-      return {
-        width: Number(imageInfo.size?.width ?? 0),
-        height: Number(imageInfo.size?.height ?? 0),
-      };
-    } catch (_error) {
-      return {
-        width: 0,
-        height: 0,
-      };
-    } finally {
-      if (imageSource) {
-        try {
-          await imageSource.release();
-        } catch (_error) {
-          // Ignore cleanup errors from ImageSource release.
-        }
-      }
-    }
-  }
-}
-`;
-}
-function renderExpoFileSystemHarmonyAdapterShim(capability) {
-    return `'use strict';
-
-const { TurboModuleRegistry } = require('react-native');
-const { CodedError } = require('expo-modules-core');
-
-const FILE_SCHEME = 'file://';
-const NATIVE_MODULE_NAME = 'ExpoHarmonyFileSystem';
-const NATIVE_MODULE = TurboModuleRegistry.get(NATIVE_MODULE_NAME);
-const NATIVE_CONSTANTS = NATIVE_MODULE?.getConstants ? NATIVE_MODULE.getConstants() : {};
-
-function createError(code, message) {
-  return new CodedError(code, message);
-}
-
-function requireNativeModule(operationName) {
-  if (NATIVE_MODULE) {
-    return NATIVE_MODULE;
-  }
-
-  throw createError(
-    'ERR_EXPO_HARMONY_NATIVE_MODULE_MISSING',
-    '${capability.packageName} expected the ' +
-      NATIVE_MODULE_NAME +
-      ' TurboModule to be registered, but it was missing while running ' +
-      operationName +
-      '.',
-  );
-}
-
-function createUnsupportedError(operationName) {
-  return createError(
-    'ERR_EXPO_HARMONY_UNSUPPORTED',
-    '${capability.packageName} currently supports UTF-8 sandbox file operations only. Unsupported operation: ' +
-      operationName +
-      '.',
-  );
-}
-
-function toFileUri(pathValue, ensureTrailingSlash) {
-  if (typeof pathValue !== 'string' || pathValue.length === 0) {
-    return null;
-  }
-
-  const normalizedPath = pathValue.startsWith(FILE_SCHEME)
-    ? pathValue.slice(FILE_SCHEME.length)
-    : pathValue;
-  const withScheme = FILE_SCHEME + normalizedPath;
-
-  if (!ensureTrailingSlash) {
-    return withScheme;
-  }
-
-  let normalizedSchemePath = withScheme;
-
-  while (normalizedSchemePath.endsWith('/')) {
-    normalizedSchemePath = normalizedSchemePath.slice(0, -1);
-  }
-
-  return normalizedSchemePath + '/';
-}
-
-function normalizeInputPath(inputPath) {
-  if (typeof inputPath !== 'string' || inputPath.length === 0) {
-    throw createError(
-      'ERR_EXPO_HARMONY_INVALID_URI',
-      '${capability.packageName} expected a non-empty file URI.',
-    );
-  }
-
-  const normalizedPath = inputPath.startsWith(FILE_SCHEME)
-    ? inputPath.slice(FILE_SCHEME.length)
-    : inputPath;
-
-  if (!normalizedPath.startsWith('/')) {
-    throw createError(
-      'ERR_EXPO_HARMONY_INVALID_URI',
-      '${capability.packageName} supports only absolute file:// URIs inside the app sandbox.',
-    );
-  }
-
-  if (
-    normalizedPath.includes('/../') ||
-    normalizedPath.endsWith('/..') ||
-    normalizedPath.includes('/./')
-  ) {
-    throw createError(
-      'ERR_EXPO_HARMONY_INVALID_URI',
-      '${capability.packageName} does not accept relative path segments.',
-    );
-  }
-
-  return normalizedPath;
-}
-
-function normalizeStringEncoding(rawEncoding) {
-  if (rawEncoding == null || rawEncoding === 'utf8') {
-    return 'utf8';
-  }
-
-  if (rawEncoding === 'base64') {
-    return 'base64';
-  }
-
-  throw createUnsupportedError('encoding=' + String(rawEncoding));
-}
-
-function normalizeFileDownloadResult(result, requestedUri) {
-  return {
-    uri: result?.uri ?? String(requestedUri),
-    status:
-      typeof result?.status === 'number' && Number.isFinite(result.status)
-        ? result.status
-        : 200,
-    headers: result?.headers && typeof result.headers === 'object' ? result.headers : {},
-    md5: typeof result?.md5 === 'string' ? result.md5 : undefined,
-  };
-}
-
-function normalizeFileInfoResult(requestedUri, nativeResult) {
-  if (!nativeResult || nativeResult.exists !== true) {
-    return {
-      exists: false,
-      isDirectory: false,
-      uri: String(requestedUri),
-    };
-  }
-
-  const normalizedResult = {
-    exists: true,
-    uri: toFileUri(nativeResult.path, false) ?? String(requestedUri),
-    size: Number(nativeResult.size ?? 0),
-    isDirectory: nativeResult.isDirectory === true,
-    modificationTime: Number(nativeResult.modificationTime ?? 0),
-  };
-
-  if (typeof nativeResult.md5 === 'string' && nativeResult.md5.length > 0) {
-    normalizedResult.md5 = nativeResult.md5;
-  }
-
-  return normalizedResult;
-}
-
-function normalizeNativeError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-
-  if (error && typeof error === 'object') {
-    const code =
-      typeof error.code === 'number' || typeof error.code === 'string'
-        ? String(error.code)
-        : null;
-    const message =
-      typeof error.message === 'string' && error.message.length > 0
-        ? error.message
-        : typeof error.name === 'string' && error.name.length > 0
-          ? error.name
-          : JSON.stringify(error);
-
-    return new Error(code ? '[native:' + code + '] ' + message : message);
-  }
-
-  return new Error(String(error));
-}
-
-module.exports = {
-  documentDirectory: toFileUri(NATIVE_CONSTANTS.documentDirectoryPath, true),
-  cacheDirectory: toFileUri(NATIVE_CONSTANTS.cacheDirectoryPath, true),
-  bundleDirectory: toFileUri(NATIVE_CONSTANTS.bundleDirectoryPath, true),
-  EncodingType: {
-    UTF8: 'utf8',
-    Base64: 'base64',
-  },
-  FileSystemSessionType: {
-    BACKGROUND: 0,
-    FOREGROUND: 1,
-  },
-  async getInfoAsync(fileUri, options) {
-    const normalizedPath = normalizeInputPath(fileUri);
-    try {
-      const result = await requireNativeModule('getInfoAsync').getInfo(normalizedPath, {
-        md5: options?.md5 === true,
-      });
-      return normalizeFileInfoResult(fileUri, result);
-    } catch (error) {
-      throw normalizeNativeError(error);
-    }
-  },
-  async readAsStringAsync(fileUri, options) {
-    const normalizedPath = normalizeInputPath(fileUri);
-    try {
-      return await requireNativeModule('readAsStringAsync').readAsString(normalizedPath, {
-        encoding: normalizeStringEncoding(options?.encoding),
-        position: options?.position,
-        length: options?.length,
-      });
-    } catch (error) {
-      throw normalizeNativeError(error);
-    }
-  },
-  async writeAsStringAsync(fileUri, contents, options) {
-    const normalizedPath = normalizeInputPath(fileUri);
-    try {
-      await requireNativeModule('writeAsStringAsync').writeAsString(
-        normalizedPath,
-        String(contents),
-        {
-          encoding: normalizeStringEncoding(options?.encoding),
-          append: options?.append === true,
-        },
-      );
-    } catch (error) {
-      throw normalizeNativeError(error);
-    }
-  },
-  async deleteAsync(fileUri, options) {
-    const normalizedPath = normalizeInputPath(fileUri);
-    try {
-      await requireNativeModule('deleteAsync').deletePath(normalizedPath, {
-        idempotent: options?.idempotent === true,
-      });
-    } catch (error) {
-      throw normalizeNativeError(error);
-    }
-  },
-  async makeDirectoryAsync(fileUri, options) {
-    const normalizedPath = normalizeInputPath(fileUri);
-    try {
-      await requireNativeModule('makeDirectoryAsync').makeDirectory(normalizedPath, {
-        intermediates: options?.intermediates === true,
-      });
-    } catch (error) {
-      throw normalizeNativeError(error);
-    }
-  },
-  async readDirectoryAsync(fileUri) {
-    const normalizedPath = normalizeInputPath(fileUri);
-    try {
-      return await requireNativeModule('readDirectoryAsync').readDirectory(normalizedPath);
-    } catch (error) {
-      throw normalizeNativeError(error);
-    }
-  },
-  async copyAsync(options) {
-    const fromPath = normalizeInputPath(options?.from);
-    const toPath = normalizeInputPath(options?.to);
-    try {
-      await requireNativeModule('copyAsync').copy(fromPath, toPath);
-    } catch (error) {
-      throw normalizeNativeError(error);
-    }
-  },
-  async moveAsync(options) {
-    const fromPath = normalizeInputPath(options?.from);
-    const toPath = normalizeInputPath(options?.to);
-    try {
-      await requireNativeModule('moveAsync').move(fromPath, toPath);
-    } catch (error) {
-      throw normalizeNativeError(error);
-    }
-  },
-  async downloadAsync(url, fileUri, options) {
-    const normalizedPath = normalizeInputPath(fileUri);
-    try {
-      return normalizeFileDownloadResult(
-        await requireNativeModule('downloadAsync').download(
-          String(url),
-          normalizedPath,
-          {
-            headers: options?.headers ?? {},
-            md5: options?.md5 === true,
-          },
-        ),
-        fileUri,
-      );
-    } catch (error) {
-      throw normalizeNativeError(error);
-    }
-  },
-};
-`;
-}
-function renderExpoFileSystemPreviewShim(capability) {
-    return `'use strict';
-
-const { CodedError } = require('expo-modules-core');
-
-const PREVIEW_MESSAGE =
-  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, but runtime file-system behavior is not verified yet.';
-
-function createPreviewError(operationName) {
-  return new CodedError(
-    'ERR_EXPO_HARMONY_PREVIEW',
-    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
-  );
-}
-
-async function unavailable(operationName) {
-  throw createPreviewError(operationName);
-}
-
-module.exports = {
-  cacheDirectory: 'file:///expo-harmony/cache/',
-  documentDirectory: 'file:///expo-harmony/document/',
-  bundleDirectory: 'file:///expo-harmony/bundle/',
-  EncodingType: {
-    UTF8: 'utf8',
-    Base64: 'base64',
-  },
-  FileSystemSessionType: {
-    BACKGROUND: 0,
-    FOREGROUND: 1,
-  },
-  getInfoAsync(path) {
-    return unavailable('getInfoAsync(' + String(path) + ')');
-  },
-  readAsStringAsync(path) {
-    return unavailable('readAsStringAsync(' + String(path) + ')');
-  },
-  writeAsStringAsync(path) {
-    return unavailable('writeAsStringAsync(' + String(path) + ')');
-  },
-  deleteAsync(path) {
-    return unavailable('deleteAsync(' + String(path) + ')');
-  },
-  makeDirectoryAsync(path) {
-    return unavailable('makeDirectoryAsync(' + String(path) + ')');
-  },
-  readDirectoryAsync(path) {
-    return unavailable('readDirectoryAsync(' + String(path) + ')');
-  },
-  copyAsync(options) {
-    return unavailable('copyAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  moveAsync(options) {
-    return unavailable('moveAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  downloadAsync(url) {
-    return unavailable('downloadAsync(' + String(url) + ')');
-  },
-};
-`;
-}
-function renderExpoImagePickerHarmonyAdapterShim(capability) {
-    return `'use strict';
-
-const { TurboModuleRegistry } = require('react-native');
-const { CodedError } = require('expo-modules-core');
-
-const NATIVE_MODULE_NAME = 'ExpoHarmonyImagePicker';
-const NATIVE_MODULE = TurboModuleRegistry.get(NATIVE_MODULE_NAME);
-
-function createError(code, message) {
-  return new CodedError(code, message);
-}
-
-function requireNativeModule(operationName) {
-  if (NATIVE_MODULE) {
-    return NATIVE_MODULE;
-  }
-
-  throw createError(
-    'ERR_EXPO_HARMONY_NATIVE_MODULE_MISSING',
-    '${capability.packageName} expected the ' +
-      NATIVE_MODULE_NAME +
-      ' TurboModule to be registered, but it was missing while running ' +
-      operationName +
-      '.',
-  );
-}
-
-function normalizeNativeError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-
-  if (error && typeof error === 'object') {
-    const code =
-      typeof error.code === 'number' || typeof error.code === 'string'
-        ? String(error.code)
-        : null;
-    const message =
-      typeof error.message === 'string' && error.message.length > 0
-        ? error.message
-        : typeof error.name === 'string' && error.name.length > 0
-          ? error.name
-          : JSON.stringify(error);
-
-    return new Error(code ? '[native:' + code + '] ' + message : message);
-  }
-
-  return new Error(String(error));
-}
-
-function normalizePickerResult(result) {
-  if (!result || result.canceled === true || !Array.isArray(result.assets) || result.assets.length === 0) {
-    return {
-      canceled: true,
-      assets: null,
-    };
-  }
-
-  return {
-    canceled: false,
-    assets: result.assets.map((asset) => ({
-      uri: String(asset.uri),
-      assetId: asset.assetId ?? null,
-      width: Number(asset.width ?? 0),
-      height: Number(asset.height ?? 0),
-      type: asset.type ?? null,
-      fileName: asset.fileName ?? null,
-      fileSize:
-        typeof asset.fileSize === 'number' && Number.isFinite(asset.fileSize)
-          ? asset.fileSize
-          : null,
-      mimeType: asset.mimeType ?? null,
-      duration:
-        typeof asset.duration === 'number' && Number.isFinite(asset.duration)
-          ? asset.duration
-          : null,
-      exif: asset.exif ?? null,
-      base64: asset.base64 ?? null,
-    })),
-  };
-}
-
-async function invokeNative(methodName, operationName, ...args) {
-  try {
-    return await requireNativeModule(operationName)[methodName](...args);
-  } catch (error) {
-    throw normalizeNativeError(error);
-  }
-}
-
-module.exports = {
-  MediaTypeOptions: {
-    All: 'All',
-    Images: 'Images',
-    Videos: 'Videos',
-  },
-  CameraType: {
-    front: 'front',
-    back: 'back',
-  },
-  UIImagePickerPresentationStyle: {
-    AUTOMATIC: 'automatic',
-    FULL_SCREEN: 'fullScreen',
-    PAGE_SHEET: 'pageSheet',
-    FORM_SHEET: 'formSheet',
-    CURRENT_CONTEXT: 'currentContext',
-    OVER_FULL_SCREEN: 'overFullScreen',
-  },
-  async requestCameraPermissionsAsync() {
-    return invokeNative(
-      'requestCameraPermission',
-      'requestCameraPermissionsAsync',
-    );
-  },
-  async requestMediaLibraryPermissionsAsync(writeOnly) {
-    return invokeNative(
-      'requestMediaLibraryPermission',
-      'requestMediaLibraryPermissionsAsync',
-      writeOnly === true,
-    );
-  },
-  async getCameraPermissionsAsync() {
-    return invokeNative('getCameraPermissionStatus', 'getCameraPermissionsAsync');
-  },
-  async getMediaLibraryPermissionsAsync(writeOnly) {
-    return invokeNative(
-      'getMediaLibraryPermissionStatus',
-      'getMediaLibraryPermissionsAsync',
-      writeOnly === true,
-    );
-  },
-  async launchCameraAsync(options) {
-    return normalizePickerResult(
-      await invokeNative('launchCamera', 'launchCameraAsync', options ?? {}),
-    );
-  },
-  async launchImageLibraryAsync(options) {
-    return normalizePickerResult(
-      await invokeNative('launchImageLibrary', 'launchImageLibraryAsync', options ?? {}),
-    );
-  },
-  async getPendingResultAsync() {
-    const result = await invokeNative('getPendingResult', 'getPendingResultAsync');
-    return result ? normalizePickerResult(result) : null;
-  },
-};
-`;
-}
-function renderExpoLocationHarmonyAdapterShim(capability) {
-    return `'use strict';
-
-const { TurboModuleRegistry } = require('react-native');
-const { CodedError } = require('expo-modules-core');
-
-const NATIVE_MODULE_NAME = 'ExpoHarmonyLocation';
-const NATIVE_MODULE = TurboModuleRegistry.get(NATIVE_MODULE_NAME);
-
-function createError(code, message) {
-  return new CodedError(code, message);
-}
-
-function createUnsupportedError(operationName) {
-  return createError(
-    'ERR_EXPO_HARMONY_UNSUPPORTED',
-    '${capability.packageName} does not implement ' + operationName + ' on HarmonyOS yet.',
-  );
-}
-
-function requireNativeModule(operationName) {
-  if (NATIVE_MODULE) {
-    return NATIVE_MODULE;
-  }
-
-  throw createError(
-    'ERR_EXPO_HARMONY_NATIVE_MODULE_MISSING',
-    '${capability.packageName} expected the ' +
-      NATIVE_MODULE_NAME +
-      ' TurboModule to be registered, but it was missing while running ' +
-      operationName +
-      '.',
-  );
-}
-
-function normalizeNativeError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-
-  if (error && typeof error === 'object') {
-    const code =
-      typeof error.code === 'number' || typeof error.code === 'string'
-        ? String(error.code)
-        : null;
-    const message =
-      typeof error.message === 'string' && error.message.length > 0
-        ? error.message
-        : typeof error.name === 'string' && error.name.length > 0
-          ? error.name
-          : JSON.stringify(error);
-
-    return new Error(code ? '[native:' + code + '] ' + message : message);
-  }
-
-  return new Error(String(error));
-}
-
-async function invokeNative(methodName, operationName, ...args) {
-  try {
-    return await requireNativeModule(operationName)[methodName](...args);
-  } catch (error) {
-    throw normalizeNativeError(error);
-  }
-}
-
-function normalizePermissionResponse(permissionResponse) {
-  return {
-    status: permissionResponse?.status ?? 'undetermined',
-    granted: permissionResponse?.granted === true,
-    canAskAgain: permissionResponse?.canAskAgain !== false,
-    expires: permissionResponse?.expires ?? 'never',
-    android: permissionResponse?.android ?? { accuracy: 'none' },
-    ios: permissionResponse?.ios ?? null,
-  };
-}
-
-function normalizeLocationObject(location) {
-  return {
-    coords: {
-      latitude: Number(location?.coords?.latitude ?? 0),
-      longitude: Number(location?.coords?.longitude ?? 0),
-      altitude:
-        typeof location?.coords?.altitude === 'number' ? location.coords.altitude : null,
-      accuracy:
-        typeof location?.coords?.accuracy === 'number' ? location.coords.accuracy : null,
-      altitudeAccuracy:
-        typeof location?.coords?.altitudeAccuracy === 'number'
-          ? location.coords.altitudeAccuracy
-          : null,
-      heading: typeof location?.coords?.heading === 'number' ? location.coords.heading : null,
-      speed: typeof location?.coords?.speed === 'number' ? location.coords.speed : null,
-    },
-    timestamp: Number(location?.timestamp ?? Date.now()),
-    mocked: location?.mocked === true,
-  };
-}
-
-function normalizeProviderStatus(providerStatus) {
-  return {
-    locationServicesEnabled: providerStatus?.locationServicesEnabled === true,
-    backgroundModeEnabled: providerStatus?.backgroundModeEnabled === true,
-    gpsAvailable: providerStatus?.gpsAvailable === true,
-    networkAvailable: providerStatus?.networkAvailable === true,
-    passiveAvailable: providerStatus?.passiveAvailable === true,
-  };
-}
-
-function normalizeReverseGeocodeResult(address) {
-  return {
-    city: address?.city ?? null,
-    district: address?.district ?? null,
-    streetNumber: address?.streetNumber ?? null,
-    street: address?.street ?? null,
-    region: address?.region ?? null,
-    subregion: address?.subregion ?? null,
-    country: address?.country ?? null,
-    postalCode: address?.postalCode ?? null,
-    name: address?.name ?? null,
-    isoCountryCode: address?.isoCountryCode ?? null,
-    timezone: address?.timezone ?? null,
-    formattedAddress: address?.formattedAddress ?? null,
-  };
-}
-
-function normalizeGeocodeInput(address) {
-  if (typeof address === 'string') {
-    return address.trim();
-  }
-
-  if (!address || typeof address !== 'object') {
-    return '';
-  }
-
-  const parts = [
-    address.name,
-    address.streetNumber,
-    address.street,
-    address.district,
-    address.city,
-    address.region,
-    address.postalCode,
-    address.country,
-  ]
-    .filter((part) => typeof part === 'string' && part.trim().length > 0)
-    .map((part) => part.trim());
-
-  return parts.join(', ');
-}
-
-function normalizeGeocodeResults(results) {
-  if (!Array.isArray(results)) {
-    return [];
-  }
-
-  return results.map((result) => ({
-    latitude: Number(result?.latitude ?? 0),
-    longitude: Number(result?.longitude ?? 0),
-    altitude: typeof result?.altitude === 'number' ? result.altitude : null,
-    accuracy: typeof result?.accuracy === 'number' ? result.accuracy : null,
-  }));
-}
-
-function normalizeHeadingObject(heading) {
-  return {
-    magHeading: Number(heading?.magHeading ?? 0),
-    trueHeading:
-      typeof heading?.trueHeading === 'number' && Number.isFinite(heading.trueHeading)
-        ? heading.trueHeading
-        : null,
-    accuracy:
-      typeof heading?.accuracy === 'number' && Number.isFinite(heading.accuracy)
-        ? heading.accuracy
-        : 0,
-  };
-}
-
-function createSubscription(remove) {
-  let active = true;
-
-  return {
-    remove() {
-      if (!active) {
-        return;
-      }
-
-      active = false;
-      remove();
-    },
-  };
-}
-
-module.exports = {
-  Accuracy: {
-    Lowest: 1,
-    Low: 2,
-    Balanced: 3,
-    High: 4,
-    Highest: 5,
-    BestForNavigation: 6,
-  },
-  PermissionStatus: {
-    DENIED: 'denied',
-    GRANTED: 'granted',
-    UNDETERMINED: 'undetermined',
-  },
-  async getForegroundPermissionsAsync() {
-    return normalizePermissionResponse(
-      await invokeNative(
-        'getForegroundPermissionStatus',
-        'getForegroundPermissionsAsync',
-      ),
-    );
-  },
-  async requestForegroundPermissionsAsync() {
-    return normalizePermissionResponse(
-      await invokeNative(
-        'requestForegroundPermission',
-        'requestForegroundPermissionsAsync',
-      ),
-    );
-  },
-  async getBackgroundPermissionsAsync() {
-    return normalizePermissionResponse(
-      await invokeNative(
-        'getBackgroundPermissionStatus',
-        'getBackgroundPermissionsAsync',
-      ),
-    );
-  },
-  async requestBackgroundPermissionsAsync() {
-    return normalizePermissionResponse(
-      await invokeNative(
-        'requestBackgroundPermission',
-        'requestBackgroundPermissionsAsync',
-      ),
-    );
-  },
-  async hasServicesEnabledAsync() {
-    return await invokeNative('hasServicesEnabled', 'hasServicesEnabledAsync');
-  },
-  async getProviderStatusAsync() {
-    return normalizeProviderStatus(
-      await invokeNative('getProviderStatus', 'getProviderStatusAsync'),
-    );
-  },
-  async getCurrentPositionAsync(options) {
-    return normalizeLocationObject(
-      await invokeNative('getCurrentPosition', 'getCurrentPositionAsync', options ?? {}),
-    );
-  },
-  async getLastKnownPositionAsync(options) {
-    const location = await invokeNative(
-      'getLastKnownPosition',
-      'getLastKnownPositionAsync',
-      options ?? {},
-    );
-    return location ? normalizeLocationObject(location) : null;
-  },
-  async geocodeAsync(address) {
-    return normalizeGeocodeResults(
-      await invokeNative(
-        'geocode',
-        'geocodeAsync',
-        normalizeGeocodeInput(address),
-      ),
-    );
-  },
-  async reverseGeocodeAsync(location) {
-    const results = await invokeNative(
-      'reverseGeocode',
-      'reverseGeocodeAsync',
-      {
-        latitude: Number(location?.latitude ?? 0),
-        longitude: Number(location?.longitude ?? 0),
-      },
-    );
-
-    if (!Array.isArray(results)) {
-      return [];
-    }
-
-    return results.map(normalizeReverseGeocodeResult);
-  },
-  async watchPositionAsync(options, callback, errorHandler) {
-    if (typeof callback !== 'function') {
-      throw createError(
-        'ERR_EXPO_HARMONY_INVALID_LISTENER',
-        '${capability.packageName} expected watchPositionAsync to receive a callback.',
-      );
-    }
-
-    try {
-      const watchResult = await invokeNative(
-        'startWatchPosition',
-        'watchPositionAsync',
-        options ?? {},
-        null,
-      );
-      const watchId =
-        typeof watchResult?.watchId === 'number' ? watchResult.watchId : Number(Date.now());
-
-      if (watchResult?.initialLocation) {
-        callback(normalizeLocationObject(watchResult.initialLocation));
-      }
-
-      return createSubscription(() => {
-        void invokeNative(
-          'stopWatchPosition',
-          'Location.watchPositionAsync.remove',
-          watchId,
-        ).catch(() => {});
-      });
-    } catch (error) {
-      if (typeof errorHandler === 'function') {
-        errorHandler(error);
-      }
-
-      throw error;
-    }
-  },
-  async watchHeadingAsync(callback) {
-    if (typeof callback !== 'function') {
-      throw createError(
-        'ERR_EXPO_HARMONY_INVALID_LISTENER',
-        '${capability.packageName} expected watchHeadingAsync to receive a callback.',
-      );
-    }
-
-    const watchResult = await invokeNative(
-      'startWatchHeading',
-      'watchHeadingAsync',
-      null,
-    );
-    const watchId =
-      typeof watchResult?.watchId === 'number' ? watchResult.watchId : Number(Date.now());
-
-    if (watchResult?.initialHeading) {
-      callback(normalizeHeadingObject(watchResult.initialHeading));
-    }
-
-    return createSubscription(() => {
-      void invokeNative(
-        'stopWatchHeading',
-        'Location.watchHeadingAsync.remove',
-        watchId,
-      ).catch(() => {});
-    });
-  },
-  async getHeadingAsync() {
-    return normalizeHeadingObject(
-      await invokeNative('getHeading', 'getHeadingAsync'),
-    );
-  },
-};
-`;
-}
-function renderExpoImagePickerPreviewShim(capability) {
-    return `'use strict';
-
-const { CodedError } = require('expo-modules-core');
-
-const PREVIEW_MESSAGE =
-  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, but picker and camera flows still need device-side validation.';
-
-function createPreviewError(operationName) {
-  return new CodedError(
-    'ERR_EXPO_HARMONY_PREVIEW',
-    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
-  );
-}
-
-async function unavailable(operationName) {
-  throw createPreviewError(operationName);
-}
-
-module.exports = {
-  MediaTypeOptions: {
-    All: 'All',
-    Images: 'Images',
-    Videos: 'Videos',
-  },
-  UIImagePickerPresentationStyle: {
-    AUTOMATIC: 'automatic',
-    FULL_SCREEN: 'fullScreen',
-    PAGE_SHEET: 'pageSheet',
-    FORM_SHEET: 'formSheet',
-    CURRENT_CONTEXT: 'currentContext',
-    OVER_FULL_SCREEN: 'overFullScreen',
-  },
-  requestCameraPermissionsAsync() {
-    return unavailable('requestCameraPermissionsAsync');
-  },
-  requestMediaLibraryPermissionsAsync() {
-    return unavailable('requestMediaLibraryPermissionsAsync');
-  },
-  getCameraPermissionsAsync() {
-    return unavailable('getCameraPermissionsAsync');
-  },
-  getMediaLibraryPermissionsAsync() {
-    return unavailable('getMediaLibraryPermissionsAsync');
-  },
-  launchCameraAsync(options) {
-    return unavailable('launchCameraAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  launchImageLibraryAsync(options) {
-    return unavailable('launchImageLibraryAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-};
-`;
-}
-function renderExpoLocationPreviewShim(capability) {
-    return `'use strict';
-
-const { CodedError } = require('expo-modules-core');
-
-const PREVIEW_MESSAGE =
-  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, but foreground permission, current-position, and watch flows still need device-side validation.';
-const DEFAULT_PERMISSION_RESPONSE = {
-  status: 'undetermined',
-  granted: false,
-  canAskAgain: true,
-  expires: 'never',
-};
-
-function createPreviewError(operationName) {
-  return new CodedError(
-    'ERR_EXPO_HARMONY_PREVIEW',
-    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
-  );
-}
-
-async function unavailable(operationName) {
-  throw createPreviewError(operationName);
-}
-
-function getPermissionResponse() {
-  return { ...DEFAULT_PERMISSION_RESPONSE };
-}
-
-module.exports = {
-  Accuracy: {
-    Lowest: 1,
-    Low: 2,
-    Balanced: 3,
-    High: 4,
-    Highest: 5,
-    BestForNavigation: 6,
-  },
-  PermissionStatus: {
-    DENIED: 'denied',
-    GRANTED: 'granted',
-    UNDETERMINED: 'undetermined',
-  },
-  requestForegroundPermissionsAsync() {
-    return unavailable('requestForegroundPermissionsAsync');
-  },
-  getForegroundPermissionsAsync() {
-    return Promise.resolve(getPermissionResponse());
-  },
-  requestBackgroundPermissionsAsync() {
-    return unavailable('requestBackgroundPermissionsAsync');
-  },
-  getBackgroundPermissionsAsync() {
-    return Promise.resolve(getPermissionResponse());
-  },
-  hasServicesEnabledAsync() {
-    return Promise.resolve(false);
-  },
-  getCurrentPositionAsync(options) {
-    return unavailable('getCurrentPositionAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  getLastKnownPositionAsync(options) {
-    return unavailable('getLastKnownPositionAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  watchPositionAsync(options) {
-    return unavailable('watchPositionAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  geocodeAsync(address) {
-    return unavailable('geocodeAsync(' + JSON.stringify(address ?? null) + ')');
-  },
-  reverseGeocodeAsync(location) {
-    return unavailable('reverseGeocodeAsync(' + JSON.stringify(location ?? null) + ')');
-  },
-};
-`;
-}
-function renderExpoCameraHarmonyAdapterShim(capability) {
-    return `'use strict';
-
-const React = require('react');
-const { TurboModuleRegistry, requireNativeComponent } = require('react-native');
-const { CodedError } = require('expo-modules-core');
-
-const NATIVE_MODULE_NAME = 'ExpoHarmonyCamera';
-const NATIVE_MODULE = TurboModuleRegistry.get(NATIVE_MODULE_NAME);
-const NativeCameraView = requireNativeComponent('ExpoHarmonyCameraView');
-const DEFAULT_PERMISSION_RESPONSE = {
-  status: 'undetermined',
-  granted: false,
-  canAskAgain: true,
-  expires: 'never',
-};
-let nextCameraViewId = 1;
-
-function createError(code, message) {
-  return new CodedError(code, message);
-}
-
-function createUnsupportedError(operationName) {
-  return createError(
-    'ERR_EXPO_HARMONY_UNSUPPORTED',
-    '${capability.packageName} does not implement ' + operationName + ' on HarmonyOS yet.',
-  );
-}
-
-function requireNativeModule(operationName) {
-  if (NATIVE_MODULE) {
-    return NATIVE_MODULE;
-  }
-
-  throw createError(
-    'ERR_EXPO_HARMONY_NATIVE_MODULE_MISSING',
-    '${capability.packageName} expected the ' +
-      NATIVE_MODULE_NAME +
-      ' TurboModule to be registered, but it was missing while running ' +
-      operationName +
-      '.',
-  );
-}
-
-function normalizeNativeError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-
-  if (error && typeof error === 'object') {
-    const code =
-      typeof error.code === 'number' || typeof error.code === 'string'
-        ? String(error.code)
-        : null;
-    const message =
-      typeof error.message === 'string' && error.message.length > 0
-        ? error.message
-        : typeof error.name === 'string' && error.name.length > 0
-          ? error.name
-          : JSON.stringify(error);
-
-    return new Error(code ? '[native:' + code + '] ' + message : message);
-  }
-
-  return new Error(String(error));
-}
-
-async function invokeNative(methodName, operationName, ...args) {
-  try {
-    return await requireNativeModule(operationName)[methodName](...args);
-  } catch (error) {
-    throw normalizeNativeError(error);
-  }
-}
-
-function normalizePermissionResponse(permissionResponse) {
-  return {
-    status: permissionResponse?.status ?? DEFAULT_PERMISSION_RESPONSE.status,
-    granted: permissionResponse?.granted === true,
-    canAskAgain: permissionResponse?.canAskAgain !== false,
-    expires: permissionResponse?.expires ?? DEFAULT_PERMISSION_RESPONSE.expires,
-  };
-}
-
-function normalizeCameraFacing(facing) {
-  return facing === 'front' ? 'front' : 'back';
-}
-
-const CameraView = React.forwardRef(function ExpoHarmonyCameraView(props, ref) {
-  const viewIdRef = React.useRef(null);
-
-  if (!viewIdRef.current) {
-    viewIdRef.current = 'expo-harmony-camera-view-' + String(nextCameraViewId++);
-  }
-
-  const viewId = viewIdRef.current;
-
-  React.useEffect(() => {
-    void invokeNative('createPreview', 'CameraView.mount', {
-      viewId,
-      facing: normalizeCameraFacing(props.facing),
-      mode: props.mode ?? 'picture',
-    }).catch(() => {});
-
-    return () => {
-      void invokeNative('disposePreview', 'CameraView.unmount', {
-        viewId,
-      }).catch(() => {});
-    };
-  }, [props.facing, props.mode, viewId]);
-
-  React.useImperativeHandle(
-    ref,
-    () => ({
-      async takePictureAsync(options) {
-        return invokeNative('takePicture', 'CameraView.takePictureAsync', {
-          viewId,
-          cameraType: normalizeCameraFacing(props.facing),
-          ...options,
-        });
-      },
-      async pausePreview() {
-        return invokeNative('pausePreview', 'CameraView.pausePreview', {
-          viewId,
-        });
-      },
-      async resumePreview() {
-        return invokeNative('resumePreview', 'CameraView.resumePreview', {
-          viewId,
-        });
-      },
-      async getAvailablePictureSizesAsync() {
-        throw createUnsupportedError('CameraView.getAvailablePictureSizesAsync');
-      },
-      async getAvailableLensesAsync() {
-        throw createUnsupportedError('CameraView.getAvailableLensesAsync');
-      },
-      async recordAsync(options) {
-        return invokeNative('startRecording', 'CameraView.recordAsync', {
-          viewId,
-          cameraType: normalizeCameraFacing(props.facing),
-          ...options,
-        });
-      },
-      async stopRecording() {
-        return invokeNative('stopRecording', 'CameraView.stopRecording', {
-          viewId,
-        });
-      },
-      async toggleRecordingAsync(options) {
-        return invokeNative('toggleRecording', 'CameraView.toggleRecordingAsync', {
-          viewId,
-          cameraType: normalizeCameraFacing(props.facing),
-          ...options,
-        });
-      },
-    }),
-    [props.facing, viewId],
-  );
-
-  return React.createElement(NativeCameraView, {
-    ...props,
-    viewId,
-    facing: normalizeCameraFacing(props.facing),
-    accessibilityLabel: props.accessibilityLabel ?? 'Expo Harmony embedded camera preview',
-    style: [
-      {
-        minHeight: 220,
-        overflow: 'hidden',
-        backgroundColor: '#111827',
-      },
-      props.style,
-    ],
-  });
-});
-
-CameraView.displayName = 'ExpoHarmonyCameraView';
-
-async function getCameraPermissionsAsync() {
-  return normalizePermissionResponse(
-    await invokeNative('getCameraPermissionStatus', 'getCameraPermissionsAsync'),
-  );
-}
-
-async function requestCameraPermissionsAsync() {
-  return normalizePermissionResponse(
-    await invokeNative('requestCameraPermission', 'requestCameraPermissionsAsync'),
-  );
-}
-
-async function getMicrophonePermissionsAsync() {
-  return normalizePermissionResponse(
-    await invokeNative('getMicrophonePermissionStatus', 'getMicrophonePermissionsAsync'),
-  );
-}
-
-async function requestMicrophonePermissionsAsync() {
-  return normalizePermissionResponse(
-    await invokeNative('requestMicrophonePermission', 'requestMicrophonePermissionsAsync'),
-  );
-}
-
-module.exports = {
-  CameraType: {
-    front: 'front',
-    back: 'back',
-  },
-  FlashMode: {
-    off: 'off',
-    on: 'on',
-    auto: 'auto',
-    torch: 'torch',
-  },
-  CameraView,
-  Camera: {
-    CameraType: {
-      front: 'front',
-      back: 'back',
-    },
-    Constants: {
-      Type: {
-        front: 'front',
-        back: 'back',
-      },
-      FlashMode: {
-        off: 'off',
-        on: 'on',
-        auto: 'auto',
-        torch: 'torch',
-      },
-    },
-    getCameraPermissionsAsync,
-    requestCameraPermissionsAsync,
-    getMicrophonePermissionsAsync,
-    requestMicrophonePermissionsAsync,
-  },
-  getCameraPermissionsAsync,
-  requestCameraPermissionsAsync,
-  getMicrophonePermissionsAsync,
-  requestMicrophonePermissionsAsync,
-  async scanFromURLAsync() {
-    throw createUnsupportedError('scanFromURLAsync');
-  },
-};
-`;
-}
-function renderExpoCameraPreviewShim(capability) {
-    return `'use strict';
-
-const React = require('react');
-const { Text, View } = require('react-native');
-const { CodedError } = require('expo-modules-core');
-
-const PREVIEW_MESSAGE =
-  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, and a managed preview surface can render, but device-side camera permission and capture flows still need validation.';
-const DEFAULT_PERMISSION_RESPONSE = {
-  status: 'undetermined',
-  granted: false,
-  canAskAgain: true,
-  expires: 'never',
-};
-
-function createPreviewError(operationName) {
-  return new CodedError(
-    'ERR_EXPO_HARMONY_PREVIEW',
-    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
-  );
-}
-
-async function unavailable(operationName) {
-  throw createPreviewError(operationName);
-}
-
-function getPermissionResponse() {
-  return { ...DEFAULT_PERMISSION_RESPONSE };
-}
-
-const CameraView = React.forwardRef(function ExpoHarmonyCameraPreview(props, ref) {
-  React.useImperativeHandle(ref, () => ({
-    takePictureAsync(options) {
-      return unavailable('CameraView.takePictureAsync(' + JSON.stringify(options ?? {}) + ')');
-    },
-    pausePreview() {
-      return unavailable('CameraView.pausePreview()');
-    },
-    resumePreview() {
-      return unavailable('CameraView.resumePreview()');
-    },
-  }));
-
-  return React.createElement(
-    View,
-    {
-      style: [
-        {
-          minHeight: 220,
-          alignItems: 'center',
-          justifyContent: 'center',
-          borderRadius: 20,
-          borderWidth: 1,
-          borderStyle: 'dashed',
-          borderColor: '#14b8a6',
-          backgroundColor: '#ccfbf1',
-          padding: 20,
-        },
-        props.style,
-      ],
-      accessibilityLabel: 'Expo Harmony preview camera surface',
-    },
-    React.createElement(
-      Text,
-      {
-        style: {
-          color: '#0f766e',
-          fontSize: 14,
-          fontWeight: '600',
-          textAlign: 'center',
-        },
-      },
-      'Expo Harmony preview camera surface',
-    ),
-  );
-});
-
-CameraView.displayName = 'ExpoHarmonyCameraPreview';
-
-module.exports = {
-  CameraType: {
-    front: 'front',
-    back: 'back',
-  },
-  FlashMode: {
-    off: 'off',
-    on: 'on',
-    auto: 'auto',
-    torch: 'torch',
-  },
-  CameraView,
-  requestCameraPermissionsAsync() {
-    return unavailable('requestCameraPermissionsAsync');
-  },
-  getCameraPermissionsAsync() {
-    return Promise.resolve(getPermissionResponse());
-  },
-  requestMicrophonePermissionsAsync() {
-    return unavailable('requestMicrophonePermissionsAsync');
-  },
-  getMicrophonePermissionsAsync() {
-    return Promise.resolve(getPermissionResponse());
-  },
-  Camera: {
-    getCameraPermissionsAsync() {
-      return Promise.resolve(getPermissionResponse());
-    },
-    requestCameraPermissionsAsync() {
-      return unavailable('Camera.requestCameraPermissionsAsync');
-    },
-    getMicrophonePermissionsAsync() {
-      return Promise.resolve(getPermissionResponse());
-    },
-    requestMicrophonePermissionsAsync() {
-      return unavailable('Camera.requestMicrophonePermissionsAsync');
-    },
-  },
-  scanFromURLAsync() {
-    return unavailable('scanFromURLAsync');
-  },
-};
-`;
-}
-function renderExpoModulesCoreHarmonyShim(expoConfig, identifiers) {
-    const embeddedExpoConfig = buildExpoConfigForShim(expoConfig, identifiers);
-    const serializedExpoConfig = JSON.stringify(embeddedExpoConfig, null, 2);
-    const primaryScheme = getPrimarySchemeForShim(embeddedExpoConfig, identifiers);
-    const linkingUri = primaryScheme ? `${primaryScheme}://` : null;
-    const serializedLinkingUri = JSON.stringify(linkingUri);
-    return `'use strict';
-
-const { Linking, Platform } = require('react-native');
-
-const embeddedExpoConfig = ${serializedExpoConfig};
-const nativeModules = Object.create(null);
-
-class EventSubscription {
-  constructor(remove) {
-    this._remove = remove;
-  }
-
-  remove() {
-    if (!this._remove) {
-      return;
-    }
-
-    const remove = this._remove;
-    this._remove = null;
-    remove();
-  }
-}
-
-class EventEmitter {
-  constructor() {
-    this._listeners = new Map();
-  }
-
-  addListener(eventName, listener) {
-    const listeners = this._listeners.get(eventName) ?? new Set();
-    listeners.add(listener);
-    this._listeners.set(eventName, listeners);
-
-    return new EventSubscription(() => {
-      listeners.delete(listener);
-
-      if (listeners.size === 0) {
-        this._listeners.delete(eventName);
-      }
-    });
-  }
-
-  removeAllListeners(eventName) {
-    if (typeof eventName === 'string') {
-      this._listeners.delete(eventName);
-      return;
-    }
-
-    this._listeners.clear();
-  }
-
-  emit(eventName, payload) {
-    const listeners = this._listeners.get(eventName);
-
-    if (!listeners) {
-      return;
-    }
-
-    for (const listener of listeners) {
-      listener(payload);
-    }
-  }
-}
-
-class LegacyEventEmitter extends EventEmitter {}
-
-class NativeModule extends EventEmitter {}
-
-class SharedObject {}
-
-class SharedRef extends SharedObject {}
-
-class CodedError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = 'CodedError';
-  }
-}
-
-class UnavailabilityError extends CodedError {
-  constructor(moduleName, propertyName) {
-    super(
-      'ERR_UNAVAILABLE',
-      propertyName
-        ? moduleName + '.' + propertyName + ' is not available on Harmony.'
-        : moduleName + ' is not available on Harmony.',
-    );
-    this.name = 'UnavailabilityError';
-  }
-}
-
-class ExpoLinkingModule extends NativeModule {
-  constructor(initialUrl) {
-    super();
-    this._currentUrl = initialUrl;
-  }
-
-  getLinkingURL() {
-    return this._currentUrl;
-  }
-
-  _setCurrentUrl(url) {
-    this._currentUrl = url;
-    this.emit('onURLReceived', {
-      url,
-    });
-  }
-}
-
-const expoLinkingModule = new ExpoLinkingModule(${serializedLinkingUri});
-
-if (Linking?.addEventListener) {
-  Linking.addEventListener('url', (event) => {
-    expoLinkingModule._setCurrentUrl(event?.url ?? null);
-  });
-}
-
-nativeModules.ExpoLinking = expoLinkingModule;
-nativeModules.ExponentConstants = {
-  manifest: embeddedExpoConfig,
-  appOwnership: null,
-  executionEnvironment: 'standalone',
-  experienceUrl: ${serializedLinkingUri},
-  linkingUri: ${serializedLinkingUri},
-  statusBarHeight: 0,
-  systemVersion: 'HarmonyOS',
-  platform: {
-    android: embeddedExpoConfig.android ?? null,
-    ios: embeddedExpoConfig.ios ?? null,
-    web: null,
-  },
-};
-nativeModules.ExpoAsset = {
-  async downloadAsync(url) {
-    return url;
-  },
-};
-nativeModules.ExpoFetchModule = {
-  NativeRequest: class NativeRequest {
-    constructor(_response) {
-      this._response = _response;
-    }
-
-    async start() {
-      throw new UnavailabilityError('ExpoFetchModule', 'NativeRequest.start');
-    }
-
-    cancel() {}
-  },
-};
-
-function requireOptionalNativeModule(name) {
-  return nativeModules[name] ?? null;
-}
-
-function requireNativeModule(name) {
-  const nativeModule = requireOptionalNativeModule(name);
-
-  if (nativeModule) {
-    return nativeModule;
-  }
-
-  throw new UnavailabilityError(name);
-}
-
-function requireNativeViewManager(name) {
-  throw new UnavailabilityError(name, 'viewManager');
-}
-
-function registerWebModule() {}
-
-async function reloadAppAsync() {}
-
-function installOnUIRuntime() {}
-
-globalThis.expo = {
-  ...(globalThis.expo ?? {}),
-  EventEmitter,
-  LegacyEventEmitter,
-  NativeModule,
-  SharedObject,
-  SharedRef,
-  modules: {
-    ...(globalThis.expo?.modules ?? {}),
-    ...nativeModules,
-  },
-};
-
-module.exports = {
-  Platform,
-  CodedError,
-  UnavailabilityError,
-  EventEmitter,
-  LegacyEventEmitter,
-  NativeModule,
-  SharedObject,
-  SharedRef,
-  requireNativeModule,
-  requireOptionalNativeModule,
-  requireNativeViewManager,
-  registerWebModule,
-  reloadAppAsync,
-  installOnUIRuntime,
-};
-`;
-}
-function renderReactNativeSafeAreaContextHarmonyShim() {
-    return `'use strict';
-
-const React = require('react');
-const { Dimensions, View } = require('react-native');
-
-function getWindowMetrics() {
-  const metrics = Dimensions.get('window') ?? { width: 0, height: 0 };
-
-  return {
-    frame: {
-      x: 0,
-      y: 0,
-      width: typeof metrics.width === 'number' ? metrics.width : 0,
-      height: typeof metrics.height === 'number' ? metrics.height : 0,
-    },
-    insets: {
-      top: 0,
-      right: 0,
-      bottom: 0,
-      left: 0,
-    },
-  };
-}
-
-const initialWindowMetrics = getWindowMetrics();
-const initialWindowSafeAreaInsets = initialWindowMetrics.insets;
-const SafeAreaInsetsContext = React.createContext(initialWindowMetrics.insets);
-const SafeAreaFrameContext = React.createContext(initialWindowMetrics.frame);
-
-function SafeAreaProvider({ children, initialMetrics = initialWindowMetrics, style }) {
-  const metrics = initialMetrics ?? initialWindowMetrics;
-
-  return React.createElement(
-    SafeAreaFrameContext.Provider,
-    { value: metrics.frame },
-    React.createElement(
-      SafeAreaInsetsContext.Provider,
-      { value: metrics.insets },
-      React.createElement(View, { style: [{ flex: 1 }, style] }, children),
-    ),
-  );
-}
-
-function NativeSafeAreaProvider(props) {
-  return React.createElement(SafeAreaProvider, props);
-}
-
-function SafeAreaView({ children, style, ...rest }) {
-  return React.createElement(View, { ...rest, style }, children);
-}
-
-function SafeAreaListener({ children }) {
-  return typeof children === 'function' ? children(initialWindowMetrics) : null;
-}
-
-function useSafeAreaInsets() {
-  return React.useContext(SafeAreaInsetsContext);
-}
-
-function useSafeAreaFrame() {
-  return React.useContext(SafeAreaFrameContext);
-}
-
-function useSafeArea() {
-  return useSafeAreaInsets();
-}
-
-function withSafeAreaInsets(Component) {
-  return React.forwardRef((props, ref) =>
-    React.createElement(Component, {
-      ...props,
-      ref,
-      insets: useSafeAreaInsets(),
-    }),
-  );
-}
-
-module.exports = {
-  EdgeInsets: undefined,
-  initialWindowMetrics,
-  initialWindowSafeAreaInsets,
-  NativeSafeAreaProvider,
-  SafeAreaConsumer: SafeAreaInsetsContext.Consumer,
-  SafeAreaFrameContext,
-  SafeAreaInsetsContext,
-  SafeAreaListener,
-  SafeAreaProvider,
-  SafeAreaView,
-  useSafeArea,
-  useSafeAreaFrame,
-  useSafeAreaInsets,
-  withSafeAreaInsets,
-};
-`;
-}
-function renderHarmonyRuntimePrelude() {
-    return `'use strict';
-
-require('react-native/Libraries/Core/InitializeCore');
-
-function requireReactNativeBaseViewConfigHarmony() {
-  try {
-    return require('react-native/Libraries/NativeComponent/BaseViewConfig.harmony');
-  } catch (_error) {
-    return null;
-  }
-}
-
-function requireRnohBaseViewConfigHarmony() {
-  try {
-    return require('@react-native-oh/react-native-harmony/Libraries/NativeComponent/BaseViewConfig.harmony');
-  } catch (_error) {
-    return null;
-  }
-}
-
-function requireReactNativeBaseViewConfig() {
-  try {
-    return require('react-native/Libraries/NativeComponent/BaseViewConfig');
-  } catch (_error) {
-    return null;
-  }
-}
-
-function requireReactNativePlatformBaseViewConfig() {
-  try {
-    return require('react-native/Libraries/NativeComponent/PlatformBaseViewConfig');
-  } catch (_error) {
-    return null;
-  }
-}
-
-function requireRnohBaseViewConfig() {
-  try {
-    return require('@react-native-oh/react-native-harmony/Libraries/NativeComponent/BaseViewConfig');
-  } catch (_error) {
-    return null;
-  }
-}
-
-function requireRnohPlatformBaseViewConfig() {
-  try {
-    return require('@react-native-oh/react-native-harmony/Libraries/NativeComponent/PlatformBaseViewConfig');
-  } catch (_error) {
-    return null;
-  }
-}
-
-function patchNativeComponentViewConfigDefaults() {
-  const harmonyBaseViewConfigModule =
-    requireReactNativeBaseViewConfigHarmony() ?? requireRnohBaseViewConfigHarmony();
-  const harmonyBaseViewConfig = harmonyBaseViewConfigModule?.default ?? harmonyBaseViewConfigModule;
-
-  if (!harmonyBaseViewConfig) {
-    return;
-  }
-
-  for (const moduleExports of [
-    requireReactNativeBaseViewConfig(),
-    requireReactNativePlatformBaseViewConfig(),
-    requireRnohBaseViewConfig(),
-    requireRnohPlatformBaseViewConfig(),
-  ]) {
-    if (moduleExports && typeof moduleExports === 'object') {
-      moduleExports.default = harmonyBaseViewConfig;
-    }
-  }
-}
-
-function installGlobalIfMissing(name, factory) {
-  if (typeof globalThis[name] !== 'undefined') {
-    return;
-  }
-
-  const value = factory();
-
-  if (typeof value !== 'undefined') {
-    globalThis[name] = value;
-  }
-}
-
-patchNativeComponentViewConfigDefaults();
-installGlobalIfMissing('FormData', () => require('react-native/Libraries/Network/FormData').default);
-installGlobalIfMissing('Blob', () => require('react-native/Libraries/Blob/Blob').default);
-installGlobalIfMissing('FileReader', () => require('react-native/Libraries/Blob/FileReader').default);
-`;
-}
-function isBinaryTemplate(relativePath) {
-    return ['.png'].includes(path_1.default.extname(relativePath));
-}
-function contentsEqual(currentContents, nextContents, binary = false) {
-    if (binary || Buffer.isBuffer(nextContents)) {
-        return currentContents.equals(Buffer.isBuffer(nextContents) ? nextContents : Buffer.from(nextContents));
-    }
-    return currentContents.toString('utf8') === nextContents;
-}
-function sortRecordByKey(record) {
-    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
-}
-function isEquivalentToolkitScript(scriptName, currentCommand, desiredCommand) {
-    if (currentCommand === desiredCommand) {
-        return true;
-    }
-    const compatibilityPatterns = {
-        'harmony:doctor': /\bexpo-harmony(?:\.js)?\s+doctor\b/,
-        'harmony:init': /\bexpo-harmony(?:\.js)?\s+init\b/,
-        'harmony:sync-template': /\bexpo-harmony(?:\.js)?\s+sync-template\b/,
-        'harmony:env': /\bexpo-harmony(?:\.js)?\s+env\b/,
-        'harmony:bundle': /\bexpo-harmony(?:\.js)?\s+bundle\b/,
-        'harmony:build:debug': /\bexpo-harmony(?:\.js)?\s+build-hap\b[\s\S]*--mode\s+debug\b/,
-        'harmony:build:release': /\bexpo-harmony(?:\.js)?\s+build-hap\b[\s\S]*--mode\s+release\b/,
-    };
-    const compatibilityPattern = compatibilityPatterns[scriptName];
-    return compatibilityPattern ? compatibilityPattern.test(currentCommand) : false;
-}
-function buildDesiredPackageScripts(packageJson) {
-    return {
-        ...constants_1.DESIRED_PACKAGE_SCRIPTS,
-    };
-}
-function buildDesiredPnpmOverrides(packageJson) {
-    const overrides = {};
-    for (const adapter of uiStack_1.UI_STACK_VALIDATED_ADAPTERS) {
-        const declaredSpecifier = packageJson.dependencies?.[adapter.canonicalPackageName] ??
-            packageJson.devDependencies?.[adapter.canonicalPackageName] ??
-            packageJson.peerDependencies?.[adapter.canonicalPackageName];
-        if (!declaredSpecifier) {
-            continue;
-        }
-        const declaredRange = semver_1.default.validRange(declaredSpecifier);
-        if (!declaredRange || !semver_1.default.satisfies(adapter.canonicalVersion, declaredRange)) {
-            continue;
-        }
-        overrides[adapter.canonicalPackageName] = adapter.canonicalVersion;
-    }
-    return sortRecordByKey(overrides);
-}
-function usesExpoRouter(packageJson) {
-    return (0, project_1.hasDeclaredDependency)(packageJson, 'expo-router');
-}
-function resolveHarmonyBundleEntryFile(packageJson) {
-    return usesExpoRouter(packageJson) ? constants_1.HARMONY_ROUTER_ENTRY_FILENAME : 'index.js';
-}
-function renderRouterHarmonyEntry(identifiers) {
-    return `require('./${constants_1.HARMONY_RUNTIME_PRELUDE_RELATIVE_PATH}');
-
-const React = require('react');
-const { AppRegistry } = require('react-native');
-const { registerRootComponent } = require('expo');
-const { ExpoRoot } = require('expo-router');
-
-const context = require.context('./app', true, /\\.[jt]sx?$/);
-
-function App() {
-  return React.createElement(ExpoRoot, {
-    context,
-  });
-}
-
-registerRootComponent(App);
-AppRegistry.registerComponent(${JSON.stringify(identifiers.slug)}, () => App);
-`;
-}
-function buildExpoConfigForShim(expoConfig, identifiers) {
-    const normalized = toSerializableValue(expoConfig);
-    const config = normalized && typeof normalized === 'object' && !Array.isArray(normalized)
-        ? { ...normalized }
-        : {};
-    config.name = config.name ?? identifiers.appName;
-    config.slug = config.slug ?? identifiers.slug;
-    config.version = config.version ?? '1.0.0';
-    if (!config.scheme) {
-        config.scheme = getPrimarySchemeForShim(config, identifiers);
-    }
-    const android = config.android && typeof config.android === 'object' && !Array.isArray(config.android)
-        ? { ...config.android }
-        : {};
-    const ios = config.ios && typeof config.ios === 'object' && !Array.isArray(config.ios)
-        ? { ...config.ios }
-        : {};
-    android.package = android.package ?? identifiers.androidPackage ?? identifiers.bundleName;
-    ios.bundleIdentifier =
-        ios.bundleIdentifier ?? identifiers.iosBundleIdentifier ?? identifiers.bundleName;
-    config.android = android;
-    config.ios = ios;
-    return config;
-}
-function getPrimarySchemeForShim(expoConfig, identifiers) {
-    const scheme = expoConfig.scheme;
-    if (typeof scheme === 'string' && scheme.trim().length > 0) {
-        return scheme.trim();
-    }
-    if (Array.isArray(scheme)) {
-        const firstScheme = scheme.find((value) => typeof value === 'string' && value.trim().length > 0);
-        if (firstScheme) {
-            return firstScheme.trim();
-        }
-    }
-    return identifiers.androidPackage ?? identifiers.iosBundleIdentifier ?? identifiers.bundleName;
-}
-function toSerializableValue(value) {
-    if (value === null ||
-        typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'boolean') {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value
-            .map((entry) => toSerializableValue(entry))
-            .filter((entry) => entry !== undefined);
-    }
-    if (typeof value === 'object') {
-        const result = {};
-        for (const [key, entry] of Object.entries(value)) {
-            const serializedEntry = toSerializableValue(entry);
-            if (serializedEntry !== undefined) {
-                result[key] = serializedEntry;
-            }
-        }
-        return result;
-    }
-    return undefined;
-}
-function collectMetadataWarnings(previousManifest, previousToolkitConfig) {
-    const warnings = [];
-    if (previousManifest && previousManifest.templateVersion !== constants_1.TEMPLATE_VERSION) {
-        warnings.push(`Existing manifest template version ${previousManifest.templateVersion} does not match current template ${constants_1.TEMPLATE_VERSION}. Sync will refresh managed metadata.`);
-    }
-    if (previousManifest && previousManifest.matrixId !== validatedMatrices_1.DEFAULT_VALIDATED_MATRIX_ID) {
-        warnings.push(`Existing manifest matrix ${previousManifest.matrixId ?? 'unknown'} does not match current matrix ${validatedMatrices_1.DEFAULT_VALIDATED_MATRIX_ID}. Sync will refresh managed metadata.`);
-    }
-    if (previousToolkitConfig && previousToolkitConfig.templateVersion !== constants_1.TEMPLATE_VERSION) {
-        warnings.push(`Existing toolkit-config template version ${previousToolkitConfig.templateVersion} does not match current template ${constants_1.TEMPLATE_VERSION}. Sync will refresh managed metadata.`);
-    }
-    if (previousToolkitConfig && previousToolkitConfig.matrixId !== validatedMatrices_1.DEFAULT_VALIDATED_MATRIX_ID) {
-        warnings.push(`Existing toolkit-config matrix ${previousToolkitConfig.matrixId ?? 'unknown'} does not match current matrix ${validatedMatrices_1.DEFAULT_VALIDATED_MATRIX_ID}. Sync will refresh managed metadata.`);
-    }
-    return warnings;
-}
-function stabilizeToolkitConfigTimestamp(previousToolkitConfig, nextToolkitConfig) {
-    if (!previousToolkitConfig) {
-        return nextToolkitConfig;
-    }
-    const { generatedAt: previousGeneratedAt, ...previousComparable } = previousToolkitConfig;
-    const { generatedAt: nextGeneratedAt, ...nextComparable } = nextToolkitConfig;
-    if (JSON.stringify(previousComparable) === JSON.stringify(nextComparable)) {
-        return {
-            ...nextToolkitConfig,
-            generatedAt: previousGeneratedAt,
-        };
-    }
-    return nextToolkitConfig;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}