@expo-harmony/config-plugins 55.0.10-harmony.2 → 55.0.10-harmony.3

package/src/mods.ts

@@ -3,11 +3,15 @@ import path from 'node:path';
 
 import {
   withBaseMod, withMod,
-  type ConfigPlugin, type ExportedConfig, type ExportedConfigWithProps, type ModPlatform,
+  type ExportedConfig, type ModPlatform,
 } from '@expo/config-plugins';
 import type { ExpoConfig } from '@expo/config-types';
 
 import { HarmonyConfigPluginError } from './errors';
+import type { ExpoConfigWithHarmony } from './config';
+import type { HarmonyModuleJson } from './manifest';
+import type { HarmonyConfigPlugin, HarmonyModAction, HarmonyModConfig } from './pluginTypes';
+import type { HarmonyResourceFile } from './resources';
 import { atomicWrite, readJson5, readText, writeJson5 } from './files';
 import {
   ManagedPaths, ProjectPaths, ResourcePaths,
@@ -21,7 +25,6 @@ export type HarmonyModName
     | 'projectBuildProfile'
     | 'rootOhPackage'
     | 'rootHvigor'
-    | 'nativeInputsStamp'
     | 'hvigorConfig'
     | 'entryBuildProfile'
     | 'entryOhPackage'
@@ -37,15 +40,13 @@ export type HarmonyModName
     | 'arktsPackageProvider'
     | 'cppPackageProvider'
     | 'cmakeLists'
-    | 'autolinking'
-    | 'manifest';
+    | 'autolinking';
 
-export type HarmonyModAction<T = unknown> = (
-  config: ExportedConfigWithProps<T>
-) => ExportedConfigWithProps<T> | Promise<ExportedConfigWithProps<T>>;
+type InternalModName = 'nativeInputsStamp' | 'manifest' | 'prepare' | 'patch';
+type AnyModName = HarmonyModName | InternalModName;
 
 export type HarmonyJson = Record<string, unknown>;
-export type HarmonyResourceMap = Record<string, HarmonyJson>;
+export type HarmonyResourceMap = Record<string, HarmonyResourceFile>;
 export type HarmonyMediaDescriptor
   = | {
     source: string;
@@ -104,11 +105,12 @@ const TextMods = new Set<FileModName>([
   'cmakeLists',
 ]);
 const ResourceMods = new Set<HarmonyModName>(['strings', 'colors', 'media']);
-const VirtualMods = new Set<HarmonyModName>(['dangerous', 'autolinking', 'manifest']);
+const VirtualMods = new Set<AnyModName>(['dangerous', 'autolinking', 'manifest', 'prepare', 'patch']);
 const ResourceModNames: readonly ResourceModName[] = ['strings', 'colors', 'media'];
 
-export const HarmonyModNames: readonly HarmonyModName[] = Object.freeze([
+const AllModNames: readonly AnyModName[] = Object.freeze([
   'dangerous',
+  'prepare',
   'reactNativeConfig',
   'appJson',
   'projectBuildProfile',
@@ -131,9 +133,14 @@ export const HarmonyModNames: readonly HarmonyModName[] = Object.freeze([
   'cppPackageProvider',
   'cmakeLists',
   'autolinking',
+  'patch',
   'manifest',
 ]);
 
+export const HarmonyModNames: readonly HarmonyModName[] = Object.freeze(
+  AllModNames.filter((name): name is HarmonyModName => name !== 'manifest' && name !== 'nativeInputsStamp' && name !== 'prepare' && name !== 'patch')
+);
+
 export function recordManagedFile(config: ManagedConfig, file: string, owner: string): void {
   config._internal ??= {};
   config._internal.harmonyManagedFiles ??= [];
@@ -146,7 +153,7 @@ export function recordManagedFile(config: ManagedConfig, file: string, owner: st
   config._internal.harmonyManagedFiles = files;
 }
 
-function assertModResults(modName: HarmonyModName, value: unknown, kind: 'json' | 'resource' | 'text'): void {
+function assertModResults(name: AnyModName, value: unknown, kind: 'json' | 'resource' | 'text'): void {
   const valid = kind === 'text'
     ? typeof value === 'string'
     : value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -154,35 +161,41 @@ function assertModResults(modName: HarmonyModName, value: unknown, kind: 'json'
   if (!valid) {
     throw new HarmonyConfigPluginError(
       'ERR_HARMONY_MOD_RESULTS_INVALID',
-      `harmony.${modName} must return ${kind === 'text' ? 'a string' : 'an object'} modResults.`,
-      { operation: `harmony.${modName}.write` }
+      `harmony.${name} must return ${kind === 'text' ? 'a string' : 'an object'} modResults.`,
+      { operation: `harmony.${name}.write` }
     );
   }
 }
 
-function withFileProvider(config: ExpoConfig, modName: FileModName): ExpoConfig {
+function withFileProvider(config: ExpoConfig, name: FileModName): ExpoConfig {
   return withBaseMod<FileResult>(config, {
     platform: 'harmony' as ModPlatform,
-    mod: modName,
+    mod: name,
     isProvider: true,
-    isIntrospective: JsonMods.has(modName),
-    saveToInternal: JsonMods.has(modName),
+    isIntrospective: JsonMods.has(name),
+    saveToInternal: JsonMods.has(name),
     async action(value) {
-      const { nextMod, ...modRequest } = value.modRequest;
-      const isProjectFile = modName in ProjectPaths;
-      const root = isProjectFile ? modRequest.projectRoot : modRequest.platformProjectRoot;
-      const file = isProjectFile
-        ? await resolveProjectPath(root, modName as keyof typeof ProjectPaths)
-        : await resolveHarmonyPath(root, ManagedPaths[modName as keyof typeof ManagedPaths]);
-      const exists = fs.existsSync(file);
-      const data = JsonMods.has(modName)
-        ? await readJson5<HarmonyJson>(file, {}, modName)
-        : await readText(file);
-
-      const request = { ...modRequest, modFile: file, modFileExists: exists } as typeof value.modRequest;
-      const result = await nextMod!({ ...value, modRequest: request, modResults: data });
-
-      assertModResults(modName, result.modResults, JsonMods.has(modName) ? 'json' : 'text');
+      const { nextMod: next, ...request } = value.modRequest;
+      const project = name in ProjectPaths;
+      const root = project ? request.projectRoot : request.platformProjectRoot;
+      const file = project
+        ? await resolveProjectPath(root, name as keyof typeof ProjectPaths)
+        : await resolveHarmonyPath(root, ManagedPaths[name as keyof typeof ManagedPaths]);
+      const exists = !request.ignoreExistingNativeFiles && fs.existsSync(file);
+      const template = value._internal?.harmonyTemplateDirectory;
+      const input = !exists && !project && typeof template === 'string'
+        ? await resolveHarmonyPath(template, ManagedPaths[name as keyof typeof ManagedPaths])
+        : file;
+
+      const data = request.ignoreExistingNativeFiles && input === file
+        ? (JsonMods.has(name) ? {} : '')
+        : JsonMods.has(name)
+          ? await readJson5<HarmonyJson>(input, {}, name)
+          : await readText(file);
+
+      const context = { ...request, modFile: file, modFileExists: exists } as typeof value.modRequest;
+      const result = await next!({ ...value, modRequest: context, modResults: data });
+      assertModResults(name, result.modResults, JsonMods.has(name) ? 'json' : 'text');
 
       if (!result.modRequest.introspect) {
         if (typeof result.modResults === 'string') {
@@ -191,7 +204,7 @@ function withFileProvider(config: ExpoConfig, modName: FileModName): ExpoConfig
           await writeJson5(file, result.modResults);
         }
 
-        recordManagedFile(result, file, modName);
+        recordManagedFile(result, file, name);
       }
 
       return result;
@@ -202,13 +215,18 @@ function withFileProvider(config: ExpoConfig, modName: FileModName): ExpoConfig
 async function readResourceMap(
   root: string,
   entries: Readonly<Record<string, string>>,
-  modName: ResourceModName
+  name: ResourceModName,
+  template?: string,
+  ignore = false
 ): Promise<HarmonyResourceMap> {
   const resources: HarmonyResourceMap = {};
 
   for (const [scope, relative] of Object.entries(entries)) {
     const file = await resolveHarmonyPath(root, relative);
-    resources[scope] = await readJson5<HarmonyJson>(file, {}, modName);
+    const fallback = ignore || !fs.existsSync(file);
+    const input = fallback && template ? await resolveHarmonyPath(template, relative) : file;
+
+    resources[scope] = ignore && input === file ? {} : await readJson5<HarmonyJson>(input, {}, name);
   }
 
   return resources;
@@ -283,10 +301,7 @@ async function writeMediaMap(
       }
 
       const item = descriptor as Partial<HarmonyMediaDescriptor>;
-      const hasSource = Object.hasOwn(item, 'source');
-      const hasContent = Object.hasOwn(item, 'content');
-
-      if (hasSource === hasContent) {
+      if (Object.hasOwn(item, 'source') === Object.hasOwn(item, 'content')) {
         throw new HarmonyConfigPluginError(
           'ERR_HARMONY_CONFIG_INVALID',
           `Harmony media ${scope}/${name} must define exactly one of source or content.`,
@@ -303,7 +318,7 @@ async function writeMediaMap(
 
       let content: string | Uint8Array;
 
-      if (hasSource) {
+      if (Object.hasOwn(item, 'source')) {
         if (typeof item.source !== 'string' || item.source.length === 0) {
           throw new HarmonyConfigPluginError(
             'ERR_HARMONY_CONFIG_INVALID',
@@ -334,11 +349,9 @@ async function writeMediaMap(
     }
   }
 
-  // Resolve and read every desired input before removing stale resources. A
-  // malformed descriptor or missing source therefore cannot partially mutate
-  // an otherwise valid generated project.
   for (const [scope, names] of Object.entries(previous)) {
     if (!(scope in ResourcePaths.media)) continue;
+
     const directory = await resolveHarmonyPath(
       root,
       ResourcePaths.media[scope as keyof typeof ResourcePaths.media]
@@ -360,9 +373,9 @@ async function writeMediaMap(
     if (replaceBase) {
       const base = path.parse(name).name;
 
-      for (const oldName of await fs.promises.readdir(directory)) {
-        if (path.parse(oldName).name === base && oldName !== name) {
-          await fs.promises.rm(path.join(directory, oldName), { force: true });
+      for (const entry of await fs.promises.readdir(directory)) {
+        if (path.parse(entry).name === base && entry !== name) {
+          await fs.promises.rm(path.join(directory, entry), { force: true });
         }
       }
     }
@@ -374,53 +387,55 @@ async function writeMediaMap(
   }
 }
 
-function withResourceProvider(config: ExpoConfig, modName: ResourceModName): ExpoConfig {
-  const isIntrospective = modName !== 'media';
+function withResourceProvider(config: ExpoConfig, name: ResourceModName): ExpoConfig {
+  const introspective = name !== 'media';
 
   return withBaseMod<ResourceResult>(config, {
     platform: 'harmony' as ModPlatform,
-    mod: modName,
+    mod: name,
     isProvider: true,
-    isIntrospective,
-    saveToInternal: isIntrospective,
+    isIntrospective: introspective,
+    saveToInternal: introspective,
     async action(value) {
-      const { nextMod, ...modRequest } = value.modRequest;
-      const root = modRequest.platformProjectRoot;
-      const data = modName === 'media'
-        ? await readMediaMap(root)
-        : await readResourceMap(root, ResourcePaths[modName], modName);
-      const previous = modName === 'media'
+      const { nextMod: next, ...request } = value.modRequest;
+      const root = request.platformProjectRoot;
+      const data = name === 'media'
+        ? (request.ignoreExistingNativeFiles
+            ? Object.fromEntries(Object.keys(ResourcePaths.media).map(scope => [scope, {}]))
+            : await readMediaMap(root))
+        : await readResourceMap(
+            root, ResourcePaths[name], name,
+            value._internal?.harmonyTemplateDirectory, request.ignoreExistingNativeFiles
+          );
+      const previous = name === 'media'
         ? Object.fromEntries(
             Object.entries(data).map(([scope, files]) => [scope, Object.keys(files)])
           )
         : {};
 
-      const result = await nextMod!({ ...value, modRequest, modResults: data });
-
-      assertModResults(modName, result.modResults, 'resource');
+      const result = await next!({ ...value, modRequest: request, modResults: data });
+      assertModResults(name, result.modResults, 'resource');
 
       if (!result.modRequest.introspect) {
-        if (modName === 'media') {
+        if (name === 'media') {
           await writeMediaMap(root, result.modResults as HarmonyMediaMap, result, previous);
         } else {
-          const paths = ResourcePaths[modName];
+          const paths = ResourcePaths[name];
 
           for (const [scope, resource] of Object.entries(result.modResults)) {
             if (!(scope in paths)) continue;
 
-            // Harmony's resource compiler requires the JSON root to contain
-            // exactly one resource-kind member. An empty scope serialized as
-            // `{}` is invalid, so omit it until a plugin contributes content.
             if (!resource || typeof resource !== 'object' || Array.isArray(resource)) {
               throw new HarmonyConfigPluginError(
                 'ERR_HARMONY_CONFIG_INVALID',
-                `Harmony ${modName} scope ${scope} must be an object.`,
-                { operation: `harmony.${modName}.write` }
+                `Harmony ${name} scope ${scope} must be an object.`,
+                { operation: `harmony.${name}.write` }
               );
             }
 
             const file = await resolveHarmonyPath(root, paths[scope as keyof typeof paths]);
 
+            // Harmony's resource compiler rejects an empty JSON root.
             if (Object.keys(resource).length === 0) {
               await fs.promises.rm(file, { force: true });
 
@@ -428,7 +443,7 @@ function withResourceProvider(config: ExpoConfig, modName: ResourceModName): Exp
             }
 
             await writeJson5(file, resource);
-            recordManagedFile(result, file, modName);
+            recordManagedFile(result, file, name);
           }
         }
       }
@@ -438,158 +453,184 @@ function withResourceProvider(config: ExpoConfig, modName: ResourceModName): Exp
   });
 }
 
-function withVirtualProvider(config: ExpoConfig, modName: HarmonyModName): ExpoConfig {
+function withVirtualProvider(config: ExpoConfig, name: AnyModName): ExpoConfig {
   return withBaseMod<null>(config, {
     platform: 'harmony' as ModPlatform,
-    mod: modName,
+    mod: name,
     isProvider: true,
+    isIntrospective: name === 'prepare',
     async action(value) {
-      const { nextMod, ...modRequest } = value.modRequest;
-
-      return nextMod!({ ...value, modRequest, modResults: null });
+      const { nextMod: next, ...request } = value.modRequest;
+      return next!({ ...value, modRequest: request, modResults: null });
     },
   });
 }
 
-function withProvider(config: ExpoConfig, modName: HarmonyModName): ExpoConfig {
+function withProvider(config: ExpoConfig, name: AnyModName): ExpoConfig {
   const actions: HarmonyModAction[] = [];
 
   config = withMod(config, {
     platform: 'harmony' as ModPlatform,
-    mod: modName,
+    mod: name,
     async action(value) {
       let result = value;
 
-      // withMod is a stack: the last registered plugin runs first. Preserve
-      // that ordering for Harmony plugins registered after the provider.
+      // Late mods must follow Expo's last-registered-first order.
       for (let index = actions.length - 1; index >= 0; index -= 1) {
-        result = await actions[index](result);
+        result = await actions[index](result as unknown as HarmonyModConfig<unknown>) as unknown as typeof result;
       }
 
       return result;
     },
   });
 
-  if (JsonMods.has(modName as FileModName) || TextMods.has(modName as FileModName)) {
-    config = withFileProvider(config, modName as FileModName);
-  } else if (ResourceMods.has(modName)) {
-    config = withResourceProvider(config, modName as ResourceModName);
-  } else if (VirtualMods.has(modName)) {
-    config = withVirtualProvider(config, modName);
+  if (JsonMods.has(name as FileModName) || TextMods.has(name as FileModName)) {
+    config = withFileProvider(config, name as FileModName);
+  } else if (ResourceMods.has(name as HarmonyModName)) {
+    config = withResourceProvider(config, name as ResourceModName);
+  } else if (VirtualMods.has(name)) {
+    config = withVirtualProvider(config, name);
   } else {
     throw new HarmonyConfigPluginError(
       'ERR_HARMONY_MOD_NOT_REGISTERED',
-      `Unknown Harmony mod: ${modName}`,
+      `Unknown Harmony mod: ${name}`,
       { operation: 'register-base-mods' }
     );
   }
 
   const mods = (config as ExportedConfig).mods as unknown as ModTable | undefined;
-  const provider = mods?.harmony?.[modName];
+  const provider = mods?.harmony?.[name];
 
   if (provider?.isProvider) provider.expoHarmonyLateActions = actions;
 
   return config;
 }
 
-export function withHarmonyBaseMods(config: ExpoConfig): ExpoConfig {
-  for (const modName of HarmonyModNames) {
+export function withHarmonyBaseMods<Config extends ExpoConfigWithHarmony>(config: Config): Config {
+  for (const name of AllModNames) {
     const mods = (config as ExportedConfig).mods as unknown as ModTable;
 
-    if (!mods?.harmony?.[modName]?.isProvider) config = withProvider(config, modName);
+    if (!mods?.harmony?.[name]?.isProvider) config = withProvider(config as ExpoConfig, name) as Config;
   }
 
   const mods = (config as ExportedConfig).mods as unknown as ModTable;
   const table = mods.harmony!;
 
   mods.harmony = Object.fromEntries([
-    ...HarmonyModNames.filter(name => table[name]).map(name => [name, table[name]]),
-    ...Object.entries(table).filter(([name]) => !HarmonyModNames.includes(name as HarmonyModName)),
+    ...AllModNames.filter(name => table[name] && name !== 'manifest' && name !== 'patch').map(name => [name, table[name]]),
+    ...Object.entries(table).filter(([name]) => !AllModNames.includes(name as AnyModName)),
+    ['patch', table.patch],
+    ['manifest', table.manifest],
   ]);
 
   return config;
 }
 
-export function withHarmonyMod<T = unknown>(
-  config: ExpoConfig,
+export function withHarmonyMod<T = unknown, Config extends ExpoConfigWithHarmony = ExpoConfigWithHarmony>(
+  config: Config,
   tuple: [HarmonyModName, HarmonyModAction<T>]
-): ExpoConfig {
+): Config {
   if (!Array.isArray(tuple) || tuple.length !== 2) {
     throw new TypeError('withHarmonyMod expects [modName, action].');
   }
 
-  const [modName, action] = tuple;
-  if (!HarmonyModNames.includes(modName) || typeof action !== 'function') {
+  const [name, action] = tuple;
+  if (!HarmonyModNames.includes(name) || typeof action !== 'function') {
     throw new HarmonyConfigPluginError(
       'ERR_HARMONY_MOD_NOT_REGISTERED',
-      `Cannot register Harmony mod: ${modName}`,
+      `Cannot register Harmony mod: ${name}`,
       { operation: 'register-mod' }
     );
   }
 
+  return registerMod(config, name, action);
+}
+
+export function registerMod<T, Config extends ExpoConfigWithHarmony>(
+  config: Config,
+  name: string,
+  action: HarmonyModAction<T>
+): Config {
   const mods = (config as ExportedConfig).mods as unknown as ModTable | undefined;
-  const provider = mods?.harmony?.[modName];
+  const provider = mods?.harmony?.[name];
 
   if (provider?.isProvider && provider.expoHarmonyLateActions) {
-    provider.expoHarmonyLateActions.push(action as HarmonyModAction);
+    // Build an ordinary Expo interceptor on an isolated mod table, preserving
+    // its registration stack, error behavior and execution trace for late mods.
+    const carrier = withMod<T>({ ...config, mods: {} } as ExpoConfig, {
+      platform: 'harmony' as ModPlatform,
+      mod: name,
+      action: action as unknown as Parameters<typeof withMod<T>>[1]['action'],
+    });
+    const interceptor = (carrier.mods as unknown as Record<string, Record<string, HarmonyModAction>>).harmony[name];
+    provider.expoHarmonyLateActions.push(interceptor);
+
     return config;
   }
 
-  return withMod<T>(config, { platform: 'harmony' as ModPlatform, mod: modName, action });
+  return withMod<T>(config as ExpoConfig, {
+    platform: 'harmony' as ModPlatform,
+    mod: name,
+    action: action as unknown as Parameters<typeof withMod<T>>[1]['action'],
+  }) as Config;
 }
 
-export const withReactNativeConfig: ConfigPlugin<HarmonyModAction<string>>
+export const withReactNativeConfig: HarmonyConfigPlugin<HarmonyModAction<string>>
   = (config, action) => withHarmonyMod(config, ['reactNativeConfig', action]);
-export const withAppJson: ConfigPlugin<HarmonyModAction<HarmonyJson>>
+export const withAppJson: HarmonyConfigPlugin<HarmonyModAction<HarmonyJson>>
   = (config, action) => withHarmonyMod(config, ['appJson', action]);
-export const withProjectBuildProfile: ConfigPlugin<HarmonyModAction<HarmonyJson>>
+export const withProjectBuildProfile: HarmonyConfigPlugin<HarmonyModAction<HarmonyJson>>
   = (config, action) => withHarmonyMod(config, ['projectBuildProfile', action]);
-export const withRootOhPackage: ConfigPlugin<HarmonyModAction<HarmonyJson>>
+export const withRootOhPackage: HarmonyConfigPlugin<HarmonyModAction<HarmonyJson>>
   = (config, action) => withHarmonyMod(config, ['rootOhPackage', action]);
-export const withRootHvigor: ConfigPlugin<HarmonyModAction<string>>
+export const withRootHvigor: HarmonyConfigPlugin<HarmonyModAction<string>>
   = (config, action) => withHarmonyMod(config, ['rootHvigor', action]);
-export const withNativeInputsStamp: ConfigPlugin<HarmonyModAction<string>>
-  = (config, action) => withHarmonyMod(config, ['nativeInputsStamp', action]);
-export const withHvigorConfig: ConfigPlugin<HarmonyModAction<HarmonyJson>>
+export const withNativeInputsStamp: HarmonyConfigPlugin<HarmonyModAction<string>>
+  = (config, action) => registerMod(config, 'nativeInputsStamp', action);
+export const withHvigorConfig: HarmonyConfigPlugin<HarmonyModAction<HarmonyJson>>
   = (config, action) => withHarmonyMod(config, ['hvigorConfig', action]);
-export const withEntryBuildProfile: ConfigPlugin<HarmonyModAction<HarmonyJson>>
+export const withEntryBuildProfile: HarmonyConfigPlugin<HarmonyModAction<HarmonyJson>>
   = (config, action) => withHarmonyMod(config, ['entryBuildProfile', action]);
-export const withEntryOhPackage: ConfigPlugin<HarmonyModAction<HarmonyJson>>
+export const withEntryOhPackage: HarmonyConfigPlugin<HarmonyModAction<HarmonyJson>>
   = (config, action) => withHarmonyMod(config, ['entryOhPackage', action]);
-export const withEntryHvigor: ConfigPlugin<HarmonyModAction<string>>
+export const withEntryHvigor: HarmonyConfigPlugin<HarmonyModAction<string>>
   = (config, action) => withHarmonyMod(config, ['entryHvigor', action]);
-export const withModuleJson: ConfigPlugin<HarmonyModAction<HarmonyJson>>
+export const withModuleJson: HarmonyConfigPlugin<HarmonyModAction<HarmonyModuleJson>>
   = (config, action) => withHarmonyMod(config, ['moduleJson', action]);
-export const withStrings: ConfigPlugin<HarmonyModAction<HarmonyResourceMap>>
+export const withStrings: HarmonyConfigPlugin<HarmonyModAction<HarmonyResourceMap>>
   = (config, action) => withHarmonyMod(config, ['strings', action]);
-export const withColors: ConfigPlugin<HarmonyModAction<HarmonyResourceMap>>
+export const withColors: HarmonyConfigPlugin<HarmonyModAction<HarmonyResourceMap>>
   = (config, action) => withHarmonyMod(config, ['colors', action]);
-export const withMedia: ConfigPlugin<HarmonyModAction<HarmonyMediaMap>>
+export const withMedia: HarmonyConfigPlugin<HarmonyModAction<HarmonyMediaMap>>
   = (config, action) => withHarmonyMod(config, ['media', action]);
-export const withProfiles: ConfigPlugin<HarmonyModAction<HarmonyJson>>
+export const withProfiles: HarmonyConfigPlugin<HarmonyModAction<HarmonyJson>>
   = (config, action) => withHarmonyMod(config, ['profiles', action]);
-export const withEntryAbility: ConfigPlugin<HarmonyModAction<string>>
+export const withEntryAbility: HarmonyConfigPlugin<HarmonyModAction<string>>
   = (config, action) => withHarmonyMod(config, ['entryAbility', action]);
-export const withIndexPage: ConfigPlugin<HarmonyModAction<string>>
+export const withIndexPage: HarmonyConfigPlugin<HarmonyModAction<string>>
   = (config, action) => withHarmonyMod(config, ['indexPage', action]);
-export const withWorker: ConfigPlugin<HarmonyModAction<string>>
+export const withWorker: HarmonyConfigPlugin<HarmonyModAction<string>>
   = (config, action) => withHarmonyMod(config, ['worker', action]);
-export const withArkTSPackageProvider: ConfigPlugin<HarmonyModAction<string>>
+export const withArkTSPackageProvider: HarmonyConfigPlugin<HarmonyModAction<string>>
   = (config, action) => withHarmonyMod(config, ['arktsPackageProvider', action]);
-export const withCppPackageProvider: ConfigPlugin<HarmonyModAction<string>>
+export const withCppPackageProvider: HarmonyConfigPlugin<HarmonyModAction<string>>
   = (config, action) => withHarmonyMod(config, ['cppPackageProvider', action]);
-export const withCMakeLists: ConfigPlugin<HarmonyModAction<string>>
+export const withCMakeLists: HarmonyConfigPlugin<HarmonyModAction<string>>
   = (config, action) => withHarmonyMod(config, ['cmakeLists', action]);
-export const withHarmonyAutolinking: ConfigPlugin<HarmonyModAction<null>>
+export const withHarmonyAutolinking: HarmonyConfigPlugin<HarmonyModAction<null>>
   = (config, action) => withHarmonyMod(config, ['autolinking', action]);
-export const withCngManifest: ConfigPlugin<HarmonyModAction<null>>
-  = (config, action) => withHarmonyMod(config, ['manifest', action]);
-export const withHarmonyDangerousMod: ConfigPlugin<HarmonyModAction<null>>
+export const withCngManifest: HarmonyConfigPlugin<HarmonyModAction<null>>
+  = (config, action) => registerMod(config, 'manifest', action);
+export const withPreparation: HarmonyConfigPlugin<HarmonyModAction<null>>
+  = (config, action) => registerMod(config, 'prepare', action);
+export const withProjectPatch: HarmonyConfigPlugin<HarmonyModAction<null>>
+  = (config, action) => registerMod(config, 'patch', action);
+export const withHarmonyDangerousMod: HarmonyConfigPlugin<HarmonyModAction<null>>
   = (config, action) => withHarmonyMod(config, ['dangerous', action]);
 
-export const withHarmonyResources: ConfigPlugin<HarmonyModAction<unknown>> = (config, action) => {
-  for (const modName of ResourceModNames) {
-    withHarmonyMod(config, [modName, action]);
+export const withHarmonyResources: HarmonyConfigPlugin<HarmonyModAction<unknown>> = (config, action) => {
+  for (const name of ResourceModNames) {
+    withHarmonyMod(config, [name, action]);
   }
 
   return config;

package/src/nativeInputs.ts

@@ -78,7 +78,6 @@ function fingerprintHarmonyNativeInputsSync(
   const files = findLocalHars(root, manifest);
 
   const hash = crypto.createHash('sha256');
-
   hash.update(`expo-harmony-native-dependencies-v${HarmonyNativeInputsFingerprintVersion}\0`);
   hash.update(Uint8Array.from(data));
   if (lock) hash.update(lock);