Merge branch 'develop' into stable

13 files changed, 460 insertions, 103 deletions

diff --git a/src/SMAPI/Framework/ModHelpers/BaseHelper.cs b/src/SMAPI/Framework/ModHelpers/BaseHelper.cs
index 5a3d4bed..12390976 100644
--- a/src/SMAPI/Framework/ModHelpers/BaseHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/BaseHelper.cs
@@ -4,20 +4,27 @@ namespace StardewModdingAPI.Framework.ModHelpers
     internal abstract class BaseHelper : IModLinked
     {
         /*********
+        ** Fields
+        *********/
+        /// <summary>The mod using this instance.</summary>
+        protected readonly IModMetadata Mod;
+
+
+        /*********
         ** Accessors
         *********/
         /// <inheritdoc />
-        public string ModID { get; }
+        public string ModID => this.Mod.Manifest.UniqueID;
 
 
         /*********
         ** Protected methods
         *********/
         /// <summary>Construct an instance.</summary>
-        /// <param name="modID">The unique ID of the relevant mod.</param>
-        protected BaseHelper(string modID)
+        /// <param name="mod">The mod using this instance.</param>
+        protected BaseHelper(IModMetadata mod)
         {
-            this.ModID = modID;
+            this.Mod = mod;
         }
     }
 }
diff --git a/src/SMAPI/Framework/ModHelpers/CommandHelper.cs b/src/SMAPI/Framework/ModHelpers/CommandHelper.cs
index 69382009..226a8d69 100644
--- a/src/SMAPI/Framework/ModHelpers/CommandHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/CommandHelper.cs
@@ -1,4 +1,5 @@
 using System;
+using StardewModdingAPI.Framework.Deprecations;
 
 namespace StardewModdingAPI.Framework.ModHelpers
 {
@@ -8,9 +9,6 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /*********
         ** Fields
         *********/
-        /// <summary>The mod using this instance.</summary>
-        private readonly IModMetadata Mod;
-
         /// <summary>Manages console commands.</summary>
         private readonly CommandManager CommandManager;
 
@@ -22,9 +20,8 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <param name="mod">The mod using this instance.</param>
         /// <param name="commandManager">Manages console commands.</param>
         public CommandHelper(IModMetadata mod, CommandManager commandManager)
-            : base(mod?.Manifest?.UniqueID ?? "SMAPI")
+            : base(mod)
         {
-            this.Mod = mod;
             this.CommandManager = commandManager;
         }
 
@@ -40,7 +37,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
         public bool Trigger(string name, string[] arguments)
         {
             SCore.DeprecationManager.Warn(
-                source: SCore.DeprecationManager.GetSourceName(this.ModID),
+                source: SCore.DeprecationManager.GetMod(this.ModID),
                 nounPhrase: $"{nameof(IModHelper)}.{nameof(IModHelper.ConsoleCommands)}.{nameof(ICommandHelper.Trigger)}",
                 version: "3.8.1",
                 severity: DeprecationLevel.Notice
diff --git a/src/SMAPI/Framework/ModHelpers/ContentHelper.cs b/src/SMAPI/Framework/ModHelpers/ContentHelper.cs
index bfca2264..3c2441e8 100644
--- a/src/SMAPI/Framework/ModHelpers/ContentHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/ContentHelper.cs
@@ -7,12 +7,15 @@ using System.IO;
 using System.Linq;
 using StardewModdingAPI.Framework.Content;
 using StardewModdingAPI.Framework.ContentManagers;
+using StardewModdingAPI.Framework.Deprecations;
 using StardewModdingAPI.Framework.Exceptions;
+using StardewModdingAPI.Framework.Reflection;
 using StardewValley;
 
 namespace StardewModdingAPI.Framework.ModHelpers
 {
     /// <summary>Provides an API for loading content assets.</summary>
+    [Obsolete]
     internal class ContentHelper : BaseHelper, IContentHelper
     {
         /*********
@@ -27,12 +30,12 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <summary>A content manager for this mod which manages files from the mod's folder.</summary>
         private readonly ModContentManager ModContentManager;
 
-        /// <summary>The friendly mod name for use in errors.</summary>
-        private readonly string ModName;
-
         /// <summary>Encapsulates monitoring and logging.</summary>
         private readonly IMonitor Monitor;
 
+        /// <summary>Simplifies access to private code.</summary>
+        private readonly Reflector Reflection;
+
 
         /*********
         ** Accessors
@@ -44,16 +47,42 @@ namespace StardewModdingAPI.Framework.ModHelpers
         public LocalizedContentManager.LanguageCode CurrentLocaleConstant => this.GameContentManager.Language;
 
         /// <summary>The observable implementation of <see cref="AssetEditors"/>.</summary>
-        internal ObservableCollection<IAssetEditor> ObservableAssetEditors { get; } = new ObservableCollection<IAssetEditor>();
+        internal ObservableCollection<IAssetEditor> ObservableAssetEditors { get; } = new();
 
         /// <summary>The observable implementation of <see cref="AssetLoaders"/>.</summary>
-        internal ObservableCollection<IAssetLoader> ObservableAssetLoaders { get; } = new ObservableCollection<IAssetLoader>();
+        internal ObservableCollection<IAssetLoader> ObservableAssetLoaders { get; } = new();
 
         /// <inheritdoc />
-        public IList<IAssetLoader> AssetLoaders => this.ObservableAssetLoaders;
+        public IList<IAssetLoader> AssetLoaders
+        {
+            get
+            {
+                SCore.DeprecationManager.Warn(
+                    source: this.Mod,
+                    nounPhrase: $"{nameof(IContentHelper)}.{nameof(IContentHelper.AssetLoaders)}",
+                    version: "3.14.0",
+                    severity: DeprecationLevel.Notice
+                );
+
+                return this.ObservableAssetLoaders;
+            }
+        }
 
         /// <inheritdoc />
-        public IList<IAssetEditor> AssetEditors => this.ObservableAssetEditors;
+        public IList<IAssetEditor> AssetEditors
+        {
+            get
+            {
+                SCore.DeprecationManager.Warn(
+                    source: this.Mod,
+                    nounPhrase: $"{nameof(IContentHelper)}.{nameof(IContentHelper.AssetEditors)}",
+                    version: "3.14.0",
+                    severity: DeprecationLevel.Notice
+                );
+
+                return this.ObservableAssetEditors;
+            }
+        }
 
 
         /*********
@@ -62,48 +91,62 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <summary>Construct an instance.</summary>
         /// <param name="contentCore">SMAPI's core content logic.</param>
         /// <param name="modFolderPath">The absolute path to the mod folder.</param>
-        /// <param name="modID">The unique ID of the relevant mod.</param>
-        /// <param name="modName">The friendly mod name for use in errors.</param>
+        /// <param name="mod">The mod using this instance.</param>
         /// <param name="monitor">Encapsulates monitoring and logging.</param>
-        public ContentHelper(ContentCoordinator contentCore, string modFolderPath, string modID, string modName, IMonitor monitor)
-            : base(modID)
+        /// <param name="reflection">Simplifies access to private code.</param>
+        public ContentHelper(ContentCoordinator contentCore, string modFolderPath, IModMetadata mod, IMonitor monitor, Reflector reflection)
+            : base(mod)
         {
-            string managedAssetPrefix = contentCore.GetManagedAssetPrefix(modID);
+            string managedAssetPrefix = contentCore.GetManagedAssetPrefix(mod.Manifest.UniqueID);
 
             this.ContentCore = contentCore;
             this.GameContentManager = contentCore.CreateGameContentManager(managedAssetPrefix + ".content");
-            this.ModContentManager = contentCore.CreateModContentManager(managedAssetPrefix, modName, modFolderPath, this.GameContentManager);
-            this.ModName = modName;
+            this.ModContentManager = contentCore.CreateModContentManager(managedAssetPrefix, this.Mod.DisplayName, modFolderPath, this.GameContentManager);
             this.Monitor = monitor;
+            this.Reflection = reflection;
         }
 
         /// <inheritdoc />
         public T Load<T>(string key, ContentSource source = ContentSource.ModFolder)
+            where T : notnull
         {
+            IAssetName assetName = this.ContentCore.ParseAssetName(key, allowLocales: source == ContentSource.GameContent);
+
             try
             {
                 this.AssertAndNormalizeAssetName(key);
                 switch (source)
                 {
                     case ContentSource.GameContent:
-                        return this.GameContentManager.Load<T>(key, this.CurrentLocaleConstant, useCache: false);
+                        if (assetName.Name.EndsWith(".xnb", StringComparison.OrdinalIgnoreCase))
+                        {
+                            assetName = this.ContentCore.ParseAssetName(assetName.Name[..^4], allowLocales: true);
+                            SCore.DeprecationManager.Warn(
+                                this.Mod,
+                                "loading assets from the Content folder with a .xnb file extension",
+                                "3.14.0",
+                                DeprecationLevel.Notice
+                            );
+                        }
+
+                        return this.GameContentManager.LoadLocalized<T>(assetName, this.CurrentLocaleConstant, useCache: false);
 
                     case ContentSource.ModFolder:
-                        return this.ModContentManager.Load<T>(key, Constants.DefaultLanguage, useCache: false);
+                        return this.ModContentManager.LoadExact<T>(assetName, useCache: false);
 
                     default:
-                        throw new SContentLoadException($"{this.ModName} failed loading content asset '{key}' from {source}: unknown content source '{source}'.");
+                        throw new SContentLoadException($"{this.Mod.DisplayName} failed loading content asset '{key}' from {source}: unknown content source '{source}'.");
                 }
             }
-            catch (Exception ex) when (!(ex is SContentLoadException))
+            catch (Exception ex) when (ex is not SContentLoadException)
             {
-                throw new SContentLoadException($"{this.ModName} failed loading content asset '{key}' from {source}.", ex);
+                throw new SContentLoadException($"{this.Mod.DisplayName} failed loading content asset '{key}' from {source}.", ex);
             }
         }
 
         /// <inheritdoc />
         [Pure]
-        public string NormalizeAssetName(string assetName)
+        public string NormalizeAssetName(string? assetName)
         {
             return this.ModContentManager.AssertAndNormalizeAssetName(assetName);
         }
@@ -117,7 +160,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
                     return this.GameContentManager.AssertAndNormalizeAssetName(key);
 
                 case ContentSource.ModFolder:
-                    return this.ModContentManager.GetInternalAssetKey(key);
+                    return this.ModContentManager.GetInternalAssetKey(key).Name;
 
                 default:
                     throw new NotSupportedException($"Unknown content source '{source}'.");
@@ -128,32 +171,41 @@ namespace StardewModdingAPI.Framework.ModHelpers
         public bool InvalidateCache(string key)
         {
             string actualKey = this.GetActualAssetKey(key, ContentSource.GameContent);
-            this.Monitor.Log($"Requested cache invalidation for '{actualKey}'.", LogLevel.Trace);
-            return this.ContentCore.InvalidateCache(asset => asset.AssetNameEquals(actualKey)).Any();
+            this.Monitor.Log($"Requested cache invalidation for '{actualKey}'.");
+            return this.ContentCore.InvalidateCache(asset => asset.Name.IsEquivalentTo(actualKey)).Any();
         }
 
         /// <inheritdoc />
         public bool InvalidateCache<T>()
+            where T : notnull
         {
-            this.Monitor.Log($"Requested cache invalidation for all assets of type {typeof(T)}. This is an expensive operation and should be avoided if possible.", LogLevel.Trace);
-            return this.ContentCore.InvalidateCache((contentManager, key, type) => typeof(T).IsAssignableFrom(type)).Any();
+            this.Monitor.Log($"Requested cache invalidation for all assets of type {typeof(T)}. This is an expensive operation and should be avoided if possible.");
+            return this.ContentCore.InvalidateCache((_, _, type) => typeof(T).IsAssignableFrom(type)).Any();
         }
 
         /// <inheritdoc />
         public bool InvalidateCache(Func<IAssetInfo, bool> predicate)
         {
-            this.Monitor.Log("Requested cache invalidation for all assets matching a predicate.", LogLevel.Trace);
+            this.Monitor.Log("Requested cache invalidation for all assets matching a predicate.");
             return this.ContentCore.InvalidateCache(predicate).Any();
         }
 
         /// <inheritdoc />
-        public IAssetData GetPatchHelper<T>(T data, string assetName = null)
+        public IAssetData GetPatchHelper<T>(T data, string? assetName = null)
+            where T : notnull
         {
             if (data == null)
                 throw new ArgumentNullException(nameof(data), "Can't get a patch helper for a null value.");
 
             assetName ??= $"temp/{Guid.NewGuid():N}";
-            return new AssetDataForObject(this.CurrentLocale, assetName, data, this.NormalizeAssetName);
+
+            return new AssetDataForObject(
+                locale: this.CurrentLocale,
+                assetName: this.ContentCore.ParseAssetName(assetName, allowLocales: true/* no way to know if it's a game or mod asset here*/),
+                data: data,
+                getNormalizedPath: this.NormalizeAssetName,
+                reflection: this.Reflection
+            );
         }
 
 
diff --git a/src/SMAPI/Framework/ModHelpers/ContentPackHelper.cs b/src/SMAPI/Framework/ModHelpers/ContentPackHelper.cs
index d39abc7d..9f4a7ceb 100644
--- a/src/SMAPI/Framework/ModHelpers/ContentPackHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/ContentPackHelper.cs
@@ -22,11 +22,11 @@ namespace StardewModdingAPI.Framework.ModHelpers
         ** Public methods
         *********/
         /// <summary>Construct an instance.</summary>
-        /// <param name="modID">The unique ID of the relevant mod.</param>
+        /// <param name="mod">The mod using this instance.</param>
         /// <param name="contentPacks">The content packs loaded for this mod.</param>
         /// <param name="createContentPack">Create a temporary content pack.</param>
-        public ContentPackHelper(string modID, Lazy<IContentPack[]> contentPacks, Func<string, IManifest, IContentPack> createContentPack)
-            : base(modID)
+        public ContentPackHelper(IModMetadata mod, Lazy<IContentPack[]> contentPacks, Func<string, IManifest, IContentPack> createContentPack)
+            : base(mod)
         {
             this.ContentPacks = contentPacks;
             this.CreateContentPack = createContentPack;
diff --git a/src/SMAPI/Framework/ModHelpers/DataHelper.cs b/src/SMAPI/Framework/ModHelpers/DataHelper.cs
index 4cbfd73f..2eaa940a 100644
--- a/src/SMAPI/Framework/ModHelpers/DataHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/DataHelper.cs
@@ -26,11 +26,11 @@ namespace StardewModdingAPI.Framework.ModHelpers
         ** Public methods
         *********/
         /// <summary>Construct an instance.</summary>
-        /// <param name="modID">The unique ID of the relevant mod.</param>
+        /// <param name="mod">The mod using this instance.</param>
         /// <param name="modFolderPath">The absolute path to the mod folder.</param>
         /// <param name="jsonHelper">The absolute path to the mod folder.</param>
-        public DataHelper(string modID, string modFolderPath, JsonHelper jsonHelper)
-            : base(modID)
+        public DataHelper(IModMetadata mod, string modFolderPath, JsonHelper jsonHelper)
+            : base(mod)
         {
             this.ModFolderPath = modFolderPath;
             this.JsonHelper = jsonHelper;
@@ -40,19 +40,21 @@ namespace StardewModdingAPI.Framework.ModHelpers
         ** JSON file
         ****/
         /// <inheritdoc />
-        public TModel ReadJsonFile<TModel>(string path) where TModel : class
+        public TModel? ReadJsonFile<TModel>(string path)
+            where TModel : class
         {
             if (!PathUtilities.IsSafeRelativePath(path))
                 throw new InvalidOperationException($"You must call {nameof(IModHelper.Data)}.{nameof(this.ReadJsonFile)} with a relative path.");
 
             path = Path.Combine(this.ModFolderPath, PathUtilities.NormalizePath(path));
-            return this.JsonHelper.ReadJsonFileIfExists(path, out TModel data)
+            return this.JsonHelper.ReadJsonFileIfExists(path, out TModel? data)
                 ? data
                 : null;
         }
 
         /// <inheritdoc />
-        public void WriteJsonFile<TModel>(string path, TModel data) where TModel : class
+        public void WriteJsonFile<TModel>(string path, TModel? data)
+            where TModel : class
         {
             if (!PathUtilities.IsSafeRelativePath(path))
                 throw new InvalidOperationException($"You must call {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.WriteJsonFile)} with a relative path (without directory climbing).");
@@ -69,7 +71,8 @@ namespace StardewModdingAPI.Framework.ModHelpers
         ** Save file
         ****/
         /// <inheritdoc />
-        public TModel ReadSaveData<TModel>(string key) where TModel : class
+        public TModel? ReadSaveData<TModel>(string key)
+            where TModel : class
         {
             if (Context.LoadStage == LoadStage.None)
                 throw new InvalidOperationException($"Can't use {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.ReadSaveData)} when a save file isn't loaded.");
@@ -80,14 +83,15 @@ namespace StardewModdingAPI.Framework.ModHelpers
             string internalKey = this.GetSaveFileKey(key);
             foreach (IDictionary<string, string> dataField in this.GetDataFields(Context.LoadStage))
             {
-                if (dataField.TryGetValue(internalKey, out string value))
+                if (dataField.TryGetValue(internalKey, out string? value))
                     return this.JsonHelper.Deserialize<TModel>(value);
             }
             return null;
         }
 
         /// <inheritdoc />
-        public void WriteSaveData<TModel>(string key, TModel model) where TModel : class
+        public void WriteSaveData<TModel>(string key, TModel? model)
+            where TModel : class
         {
             if (Context.LoadStage == LoadStage.None)
                 throw new InvalidOperationException($"Can't use {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.WriteSaveData)} when a save file isn't loaded.");
@@ -95,7 +99,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
                 throw new InvalidOperationException($"Can't use {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.WriteSaveData)} when connected to a remote host. (Save files are stored on the main player's computer.)");
 
             string internalKey = this.GetSaveFileKey(key);
-            string data = model != null
+            string? data = model != null
                 ? this.JsonHelper.Serialize(model, Formatting.None)
                 : null;
 
@@ -112,16 +116,18 @@ namespace StardewModdingAPI.Framework.ModHelpers
         ** Global app data
         ****/
         /// <inheritdoc />
-        public TModel ReadGlobalData<TModel>(string key) where TModel : class
+        public TModel? ReadGlobalData<TModel>(string key)
+            where TModel : class
         {
             string path = this.GetGlobalDataPath(key);
-            return this.JsonHelper.ReadJsonFileIfExists(path, out TModel data)
+            return this.JsonHelper.ReadJsonFileIfExists(path, out TModel? data)
                 ? data
                 : null;
         }
 
         /// <inheritdoc />
-        public void WriteGlobalData<TModel>(string key, TModel data) where TModel : class
+        public void WriteGlobalData<TModel>(string key, TModel? data)
+            where TModel : class
         {
             string path = this.GetGlobalDataPath(key);
             if (data != null)
diff --git a/src/SMAPI/Framework/ModHelpers/GameContentHelper.cs b/src/SMAPI/Framework/ModHelpers/GameContentHelper.cs
new file mode 100644
index 00000000..232e9287
--- /dev/null
+++ b/src/SMAPI/Framework/ModHelpers/GameContentHelper.cs
@@ -0,0 +1,145 @@
+using System;
+using System.Linq;
+using StardewModdingAPI.Framework.Content;
+using StardewModdingAPI.Framework.ContentManagers;
+using StardewModdingAPI.Framework.Exceptions;
+using StardewModdingAPI.Framework.Reflection;
+using StardewValley;
+
+namespace StardewModdingAPI.Framework.ModHelpers
+{
+    /// <inheritdoc cref="IGameContentHelper"/>
+    internal class GameContentHelper : BaseHelper, IGameContentHelper
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>SMAPI's core content logic.</summary>
+        private readonly ContentCoordinator ContentCore;
+
+        /// <summary>The underlying game content manager.</summary>
+        private readonly IContentManager GameContentManager;
+
+        /// <summary>The friendly mod name for use in errors.</summary>
+        private readonly string ModName;
+
+        /// <summary>Encapsulates monitoring and logging.</summary>
+        private readonly IMonitor Monitor;
+
+        /// <summary>Simplifies access to private code.</summary>
+        private readonly Reflector Reflection;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <inheritdoc />
+        public string CurrentLocale => this.GameContentManager.GetLocale();
+
+        /// <inheritdoc />
+        public LocalizedContentManager.LanguageCode CurrentLocaleConstant => this.GameContentManager.Language;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="contentCore">SMAPI's core content logic.</param>
+        /// <param name="mod">The mod using this instance.</param>
+        /// <param name="modName">The friendly mod name for use in errors.</param>
+        /// <param name="monitor">Encapsulates monitoring and logging.</param>
+        /// <param name="reflection">Simplifies access to private code.</param>
+        public GameContentHelper(ContentCoordinator contentCore, IModMetadata mod, string modName, IMonitor monitor, Reflector reflection)
+            : base(mod)
+        {
+            string managedAssetPrefix = contentCore.GetManagedAssetPrefix(mod.Manifest.UniqueID);
+
+            this.ContentCore = contentCore;
+            this.GameContentManager = contentCore.CreateGameContentManager(managedAssetPrefix + ".content");
+            this.ModName = modName;
+            this.Monitor = monitor;
+            this.Reflection = reflection;
+        }
+
+        /// <inheritdoc />
+        public IAssetName ParseAssetName(string rawName)
+        {
+            return this.ContentCore.ParseAssetName(rawName, allowLocales: true);
+        }
+
+        /// <inheritdoc />
+        public T Load<T>(string key)
+            where T : notnull
+        {
+            IAssetName assetName = this.ContentCore.ParseAssetName(key, allowLocales: true);
+            return this.Load<T>(assetName);
+        }
+
+        /// <inheritdoc />
+        public T Load<T>(IAssetName assetName)
+            where T : notnull
+        {
+            try
+            {
+                return this.GameContentManager.LoadLocalized<T>(assetName, this.CurrentLocaleConstant, useCache: true);
+            }
+            catch (Exception ex) when (ex is not SContentLoadException)
+            {
+                throw new SContentLoadException($"{this.ModName} failed loading content asset '{assetName}' from the game content.", ex);
+            }
+        }
+
+        /// <inheritdoc />
+        public bool InvalidateCache(string key)
+        {
+            IAssetName assetName = this.ParseAssetName(key);
+            return this.InvalidateCache(assetName);
+        }
+
+        /// <inheritdoc />
+        public bool InvalidateCache(IAssetName assetName)
+        {
+            this.Monitor.Log($"Requested cache invalidation for '{assetName}'.");
+            return this.ContentCore.InvalidateCache(asset => asset.Name.IsEquivalentTo(assetName)).Any();
+        }
+
+        /// <inheritdoc />
+        public bool InvalidateCache<T>()
+            where T : notnull
+        {
+            this.Monitor.Log($"Requested cache invalidation for all assets of type {typeof(T)}. This is an expensive operation and should be avoided if possible.");
+            return this.ContentCore.InvalidateCache((_, _, type) => typeof(T).IsAssignableFrom(type)).Any();
+        }
+
+        /// <inheritdoc />
+        public bool InvalidateCache(Func<IAssetInfo, bool> predicate)
+        {
+            this.Monitor.Log("Requested cache invalidation for all assets matching a predicate.");
+            return this.ContentCore.InvalidateCache(predicate).Any();
+        }
+
+        /// <inheritdoc />
+        public IAssetData GetPatchHelper<T>(T data, string? assetName = null)
+            where T : notnull
+        {
+            if (data == null)
+                throw new ArgumentNullException(nameof(data), "Can't get a patch helper for a null value.");
+
+            assetName ??= $"temp/{Guid.NewGuid():N}";
+
+            return new AssetDataForObject(
+                locale: this.CurrentLocale,
+                assetName: this.ContentCore.ParseAssetName(assetName, allowLocales: true),
+                data: data,
+                getNormalizedPath: key => this.ParseAssetName(key).Name,
+                reflection: this.Reflection
+            );
+        }
+
+        /// <summary>Get the underlying game content manager.</summary>
+        internal IContentManager GetUnderlyingContentManager()
+        {
+            return this.GameContentManager;
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/ModHelpers/InputHelper.cs b/src/SMAPI/Framework/ModHelpers/InputHelper.cs
index 88caf4c3..6c158258 100644
--- a/src/SMAPI/Framework/ModHelpers/InputHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/InputHelper.cs
@@ -18,10 +18,10 @@ namespace StardewModdingAPI.Framework.ModHelpers
         ** Public methods
         *********/
         /// <summary>Construct an instance.</summary>
-        /// <param name="modID">The unique ID of the relevant mod.</param>
+        /// <param name="mod">The mod using this instance.</param>
         /// <param name="currentInputState">Manages the game's input state for the current player instance. That may not be the main player in split-screen mode.</param>
-        public InputHelper(string modID, Func<SInputState> currentInputState)
-            : base(modID)
+        public InputHelper(IModMetadata mod, Func<SInputState> currentInputState)
+            : base(mod)
         {
             this.CurrentInputState = currentInputState;
         }
diff --git a/src/SMAPI/Framework/ModHelpers/ModContentHelper.cs b/src/SMAPI/Framework/ModHelpers/ModContentHelper.cs
new file mode 100644
index 00000000..def0b728
--- /dev/null
+++ b/src/SMAPI/Framework/ModHelpers/ModContentHelper.cs
@@ -0,0 +1,101 @@
+using System;
+using Microsoft.Xna.Framework.Content;
+using StardewModdingAPI.Framework.Content;
+using StardewModdingAPI.Framework.ContentManagers;
+using StardewModdingAPI.Framework.Exceptions;
+using StardewModdingAPI.Framework.Reflection;
+using StardewModdingAPI.Toolkit.Utilities;
+
+namespace StardewModdingAPI.Framework.ModHelpers
+{
+    /// <inheritdoc cref="IModContentHelper"/>
+    internal class ModContentHelper : BaseHelper, IModContentHelper
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>SMAPI's core content logic.</summary>
+        private readonly ContentCoordinator ContentCore;
+
+        /// <summary>A content manager for this mod which manages files from the mod's folder.</summary>
+        private readonly ModContentManager ModContentManager;
+
+        /// <summary>The friendly mod name for use in errors.</summary>
+        private readonly string ModName;
+
+        /// <summary>A case-insensitive lookup of relative paths within the <see cref="ContentManager.RootDirectory"/>.</summary>
+        private readonly CaseInsensitivePathLookup RelativePathCache;
+
+        /// <summary>Simplifies access to private code.</summary>
+        private readonly Reflector Reflection;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="contentCore">SMAPI's core content logic.</param>
+        /// <param name="modFolderPath">The absolute path to the mod folder.</param>
+        /// <param name="mod">The mod using this instance.</param>
+        /// <param name="modName">The friendly mod name for use in errors.</param>
+        /// <param name="gameContentManager">The game content manager used for map tilesheets not provided by the mod.</param>
+        /// <param name="relativePathCache">A case-insensitive lookup of relative paths within the <paramref name="relativePathCache"/>.</param>
+        /// <param name="reflection">Simplifies access to private code.</param>
+        public ModContentHelper(ContentCoordinator contentCore, string modFolderPath, IModMetadata mod, string modName, IContentManager gameContentManager, CaseInsensitivePathLookup relativePathCache, Reflector reflection)
+            : base(mod)
+        {
+            string managedAssetPrefix = contentCore.GetManagedAssetPrefix(mod.Manifest.UniqueID);
+
+            this.ContentCore = contentCore;
+            this.ModContentManager = contentCore.CreateModContentManager(managedAssetPrefix, modName, modFolderPath, gameContentManager);
+            this.ModName = modName;
+            this.RelativePathCache = relativePathCache;
+            this.Reflection = reflection;
+        }
+
+        /// <inheritdoc />
+        public T Load<T>(string relativePath)
+            where T : notnull
+        {
+            relativePath = this.RelativePathCache.GetAssetName(relativePath);
+
+            IAssetName assetName = this.ContentCore.ParseAssetName(relativePath, allowLocales: false);
+
+            try
+            {
+                return this.ModContentManager.LoadExact<T>(assetName, useCache: false);
+            }
+            catch (Exception ex) when (ex is not SContentLoadException)
+            {
+                throw new SContentLoadException($"{this.ModName} failed loading content asset '{relativePath}' from its mod folder.", ex);
+            }
+        }
+
+        /// <inheritdoc />
+        public IAssetName GetInternalAssetName(string relativePath)
+        {
+            relativePath = this.RelativePathCache.GetAssetName(relativePath);
+            return this.ModContentManager.GetInternalAssetKey(relativePath);
+        }
+
+        /// <inheritdoc />
+        public IAssetData GetPatchHelper<T>(T data, string? relativePath = null)
+            where T : notnull
+        {
+            if (data == null)
+                throw new ArgumentNullException(nameof(data), "Can't get a patch helper for a null value.");
+
+            relativePath = relativePath != null
+                ? this.RelativePathCache.GetAssetName(relativePath)
+                : $"temp/{Guid.NewGuid():N}";
+
+            return new AssetDataForObject(
+                locale: this.ContentCore.GetLocale(),
+                assetName: this.ContentCore.ParseAssetName(relativePath, allowLocales: false),
+                data: data,
+                getNormalizedPath: key => this.ContentCore.ParseAssetName(key, allowLocales: false).Name,
+                reflection: this.Reflection
+            );
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/ModHelpers/ModHelper.cs b/src/SMAPI/Framework/ModHelpers/ModHelper.cs
index 058bff83..a23a9beb 100644
--- a/src/SMAPI/Framework/ModHelpers/ModHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/ModHelper.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using StardewModdingAPI.Events;
+using StardewModdingAPI.Framework.Deprecations;
 using StardewModdingAPI.Framework.Input;
 
 namespace StardewModdingAPI.Framework.ModHelpers
@@ -9,6 +10,14 @@ namespace StardewModdingAPI.Framework.ModHelpers
     internal class ModHelper : BaseHelper, IModHelper, IDisposable
     {
         /*********
+        ** Fields
+        *********/
+        /// <summary>The backing field for <see cref="Content"/>.</summary>
+        [Obsolete]
+        private readonly ContentHelper ContentImpl;
+
+
+        /*********
         ** Accessors
         *********/
         /// <inheritdoc />
@@ -18,7 +27,27 @@ namespace StardewModdingAPI.Framework.ModHelpers
         public IModEvents Events { get; }
 
         /// <inheritdoc />
-        public IContentHelper Content { get; }
+        [Obsolete]