From 7d8aa1c4497551f5c4249c56a161f37b2d31cdf7 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 17 Apr 2026 08:25:28 +0000
Subject: [PATCH 01/21] Support linking to UE assets, Blueprints, and C++
 classes from Markdown

Implements issue #61. Standard Markdown links whose target begins with a
UE package root (/Game/, /Engine/, /Plugins/, /Script/) are rewritten to
the ueasset:// scheme and open in their asset editor. The class://
scheme resolves to a native UClass (opened in the IDE via
FSourceCodeNavigation) or a Blueprint asset (opened in the Blueprint
editor). Broken-link styling now covers ueasset:// and class:// targets.

https://claude.ai/code/session_01TNergLaAd33WFGjABwPLpE
---
 CHANGELOG.md                                  |   8 +
 .../MarkdownAsset/Private/MarkdownAsset.cpp   |  67 +++++
 .../MarkdownAssetEditor.Build.cs              |   3 +-
 .../Private/MarkdownAssetEditorToolkit.cpp    | 259 +++++++++++++++---
 .../Public/MarkdownAssetEditorToolkit.h       |   6 +
 README.ja.md                                  |   1 +
 README.md                                     |   1 +
 7 files changed, 313 insertions(+), 32 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 18e7e1d..ce6974e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [Unreleased]
+
+### Added
+
+- **Asset & Class Links** — Standard Markdown links whose target begins with a UE package root (`/Game/`, `/Engine/`, `/Plugins/`, `/Script/`) are now opened in the corresponding asset editor from the HTML preview
+- **Class Link Scheme** — `[Label](class://ClassName)` resolves the target via UClass lookup; native C++ classes open in the IDE via `FSourceCodeNavigation::NavigateToClass`, Blueprint classes open in the Blueprint editor
+- **Broken Link Styling for New Schemes** — `ueasset://` and `class://` targets that cannot be resolved are highlighted in red in the preview, matching existing wikilink behavior
+
 ## [1.1.0] - 2026-04-04
 
 ### Added
diff --git a/Plugins/MarkdownAsset/Source/MarkdownAsset/Private/MarkdownAsset.cpp b/Plugins/MarkdownAsset/Source/MarkdownAsset/Private/MarkdownAsset.cpp
index f32ee21..3a86241 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAsset/Private/MarkdownAsset.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAsset/Private/MarkdownAsset.cpp
@@ -72,6 +72,72 @@ static FString PostProcessWikilinks(const FString& Html)
 	return Result;
 }
 
+/** Decodes HTML numeric/named entities that md4c emits inside href values (e.g. &amp;, &#x2F;). */
+static FString DecodeHtmlEntitiesInHref(const FString& Input)
+{
+	FString Output = Input;
+	Output.ReplaceInline(TEXT("&amp;"), TEXT("&"));
+	Output.ReplaceInline(TEXT("&#x2F;"), TEXT("/"));
+	Output.ReplaceInline(TEXT("&#47;"), TEXT("/"));
+	Output.ReplaceInline(TEXT("&lt;"), TEXT("<"));
+	Output.ReplaceInline(TEXT("&gt;"), TEXT(">"));
+	Output.ReplaceInline(TEXT("&quot;"), TEXT("\""));
+	return Output;
+}
+
+/**
+ * Rewrites anchor tags whose href targets a UE package path or class reference
+ * into custom URL schemes intercepted by the editor toolkit:
+ *   [Label](/Game/Foo/Bar)         -> <a href="ueasset:///Game/Foo/Bar">
+ *   [Label](class://MyClass)       -> <a href="class://MyClass">          (normalized)
+ * http/https/mdasset/data URLs are left untouched.
+ */
+static FString PostProcessAssetAndClassLinks(const FString& Html)
+{
+	// Capture every <a href="..."> (non-greedy) so we can classify the href.
+	const FRegexPattern AnchorPattern(TEXT("<a href=\"([^\"]*)\""));
+	FRegexMatcher Matcher(AnchorPattern, Html);
+
+	FString Processed;
+	int32 LastPos = 0;
+
+	while (Matcher.FindNext())
+	{
+		Processed += Html.Mid(LastPos, Matcher.GetMatchBeginning() - LastPos);
+
+		FString Href = Matcher.GetCaptureGroup(1);
+		const FString DecodedHref = DecodeHtmlEntitiesInHref(Href);
+
+		const bool bIsPackagePath =
+			DecodedHref.StartsWith(TEXT("/Game/")) ||
+			DecodedHref.StartsWith(TEXT("/Engine/")) ||
+			DecodedHref.StartsWith(TEXT("/Plugins/")) ||
+			DecodedHref.StartsWith(TEXT("/Script/"));
+		const bool bIsClassScheme = DecodedHref.StartsWith(TEXT("class://"));
+
+		if (bIsPackagePath)
+		{
+			const FString Encoded = PercentEncode(DecodedHref);
+			Processed += FString::Printf(TEXT("<a href=\"ueasset://%s\""), *Encoded);
+		}
+		else if (bIsClassScheme)
+		{
+			const FString ClassName = DecodedHref.Mid(FString(TEXT("class://")).Len());
+			const FString Encoded = PercentEncode(ClassName);
+			Processed += FString::Printf(TEXT("<a href=\"class://%s\""), *Encoded);
+		}
+		else
+		{
+			Processed += Html.Mid(Matcher.GetMatchBeginning(), Matcher.GetMatchEnding() - Matcher.GetMatchBeginning());
+		}
+
+		LastPos = Matcher.GetMatchEnding();
+	}
+	Processed += Html.Mid(LastPos);
+
+	return Processed;
+}
+
 /**
  * Helper function for md4c-html callback to append output to a string.
  */
@@ -109,6 +175,7 @@ FString UMarkdownAsset::GetParsedHTML() const
 	}
 
 	OutputHtml = PostProcessWikilinks(OutputHtml);
+	OutputHtml = PostProcessAssetAndClassLinks(OutputHtml);
 
 	return OutputHtml;
 }
diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/MarkdownAssetEditor.Build.cs b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/MarkdownAssetEditor.Build.cs
index 4550139..c002258 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/MarkdownAssetEditor.Build.cs
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/MarkdownAssetEditor.Build.cs
@@ -29,7 +29,8 @@ public MarkdownAssetEditor(ReadOnlyTargetRules Target) : base(Target)
 				"AppFramework",
 				"WorkspaceMenuStructure",
 				"WebBrowser",
-				"AssetRegistry"
+				"AssetRegistry",
+				"SourceCodeAccess"
 			}
 		);
 	}
diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index f89066b..1f2d3c0 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -20,6 +20,10 @@
 #include "AssetRegistry/AssetRegistryModule.h"
 #include "Subsystems/AssetEditorSubsystem.h"
 #include "Internationalization/Regex.h"
+#include "SourceCodeNavigation.h"
+#include "Engine/Blueprint.h"
+#include "UObject/UObjectGlobals.h"
+#include "UObject/SoftObjectPath.h"
 
 #define LOCTEXT_NAMESPACE "MarkdownAssetEditor"
 
@@ -82,33 +86,110 @@ static FString GenerateStyledHtml(const FString& ParsedHtml)
 		"del { color: #888; }\n"
 "a[href^=\"mdasset://\"] { color: #4ec9b0; text-decoration: none; border-bottom: 1px dashed #4ec9b0; cursor: pointer; }\n"
 "a[href^=\"mdasset://\"]:hover { color: #6fe0c8; border-bottom-style: solid; }\n"
+"a[href^=\"ueasset://\"] { color: #dcdcaa; text-decoration: none; border-bottom: 1px dashed #dcdcaa; cursor: pointer; }\n"
+"a[href^=\"ueasset://\"]:hover { color: #f1e9a6; border-bottom-style: solid; }\n"
+"a[href^=\"class://\"] { color: #c586c0; text-decoration: none; border-bottom: 1px dashed #c586c0; cursor: pointer; }\n"
+"a[href^=\"class://\"]:hover { color: #d7a7d2; border-bottom-style: solid; }\n"
 "a.md-broken-link { color: #f44747; border-bottom-color: #f44747; }\n"
 "a.md-broken-link:hover { color: #ff6b6b; }\n"
 		"</style></head><body>\n%s\n</body></html>"
 	), *ParsedHtml);
 }
 
+/** Returns true if an Unreal asset exists at the given object path. */
+static bool DoesAssetExistAtPath(const FString& ObjectPath)
+{
+	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
+	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+
+	const FSoftObjectPath SoftPath(ObjectPath);
+	if (AssetRegistry.GetAssetByObjectPath(SoftPath).IsValid())
+	{
+		return true;
+	}
+
+	// Content Browser paths often omit the trailing ".AssetName"; try appending it.
+	int32 SlashIndex;
+	if (!ObjectPath.Contains(TEXT(".")) && ObjectPath.FindLastChar(TEXT('/'), SlashIndex))
+	{
+		const FString LeafName = ObjectPath.Mid(SlashIndex + 1);
+		const FString FullPath = FString::Printf(TEXT("%s.%s"), *ObjectPath, *LeafName);
+		if (AssetRegistry.GetAssetByObjectPath(FSoftObjectPath(FullPath)).IsValid())
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/** Returns true if a native UClass or Blueprint class matching ClassName can be resolved. */
+static bool DoesClassExist(const FString& ClassName)
+{
+	if (ClassName.IsEmpty())
+	{
+		return false;
+	}
+
+	// Native class lookup (tries exact name, then common A/U prefixes).
+	TArray<FString> Candidates = { ClassName };
+	if (!ClassName.StartsWith(TEXT("A")) && !ClassName.StartsWith(TEXT("U")))
+	{
+		Candidates.Add(FString::Printf(TEXT("A%s"), *ClassName));
+		Candidates.Add(FString::Printf(TEXT("U%s"), *ClassName));
+	}
+	for (const FString& Candidate : Candidates)
+	{
+		if (FindFirstObject<UClass>(*Candidate, EFindFirstObjectOptions::NativeFirst) != nullptr)
+		{
+			return true;
+		}
+	}
+
+	// Blueprint fallback via Asset Registry (accepts both "BP_Foo" and "BP_Foo_C").
+	FString BlueprintAssetName = ClassName;
+	if (BlueprintAssetName.EndsWith(TEXT("_C")))
+	{
+		BlueprintAssetName.LeftChopInline(2);
+	}
+
+	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
+	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+
+	TArray<FAssetData> BlueprintAssets;
+	AssetRegistry.GetAssetsByClass(UBlueprint::StaticClass()->GetClassPathName(), BlueprintAssets);
+	for (const FAssetData& Asset : BlueprintAssets)
+	{
+		if (Asset.AssetName.ToString() == BlueprintAssetName)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
 /**
- * Checks each mdasset:// link against the AssetRegistry and adds the
- * "md-broken-link" CSS class to links whose target asset does not exist.
+ * Walks every <a href="..."> tag and adds the "md-broken-link" CSS class when
+ * the target of an mdasset://, ueasset://, or class:// scheme cannot be resolved.
+ * External URLs and other schemes are left untouched.
  */
-static FString MarkBrokenWikilinks(const FString& Html)
+static FString MarkBrokenLinks(const FString& Html)
 {
-	// Collect existing MarkdownAsset names
+	// Cache MarkdownAsset names once for mdasset:// lookups.
 	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
 	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
 
 	TArray<FAssetData> AllMarkdownAssets;
 	AssetRegistry.GetAssetsByClass(UMarkdownAsset::StaticClass()->GetClassPathName(), AllMarkdownAssets);
 
-	TSet<FString> ExistingNames;
+	TSet<FString> MarkdownAssetNames;
 	for (const FAssetData& Asset : AllMarkdownAssets)
 	{
-		ExistingNames.Add(Asset.AssetName.ToString());
+		MarkdownAssetNames.Add(Asset.AssetName.ToString());
 	}
 
-	// Find mdasset:// links and add md-broken-link class if target not found
-	const FRegexPattern LinkPattern(TEXT("<a href=\"mdasset://([^\"]*)\""));
+	const FRegexPattern LinkPattern(TEXT("<a href=\"(mdasset|ueasset|class)://([^\"]*)\""));
 	FRegexMatcher Matcher(LinkPattern, Html);
 
 	FString Result;
@@ -118,33 +199,31 @@ static FString MarkBrokenWikilinks(const FString& Html)
 	{
 		Result += Html.Mid(LastPos, Matcher.GetMatchBeginning() - LastPos);
 
-		FString EncodedTarget = Matcher.GetCaptureGroup(1);
+		const FString Scheme = Matcher.GetCaptureGroup(1);
+		const FString EncodedTarget = Matcher.GetCaptureGroup(2);
+		const FString DecodedTarget = PercentDecode(EncodedTarget);
 
-		// Percent-decode to get the original asset name
-		TArray<uint8> Bytes;
-		for (int32 i = 0; i < EncodedTarget.Len(); ++i)
+		bool bTargetExists = false;
+		if (Scheme == TEXT("mdasset"))
 		{
-			if (EncodedTarget[i] == TEXT('%') && i + 2 < EncodedTarget.Len())
-			{
-				FString HexStr = EncodedTarget.Mid(i + 1, 2);
-				Bytes.Add(static_cast<uint8>(FCString::Strtoi(*HexStr, nullptr, 16)));
-				i += 2;
-			}
-			else
-			{
-				Bytes.Add(static_cast<uint8>(EncodedTarget[i] & 0xFF));
-			}
+			bTargetExists = MarkdownAssetNames.Contains(DecodedTarget);
+		}
+		else if (Scheme == TEXT("ueasset"))
+		{
+			bTargetExists = DoesAssetExistAtPath(DecodedTarget);
+		}
+		else // class
+		{
+			bTargetExists = DoesClassExist(DecodedTarget);
 		}
-		FUTF8ToTCHAR Converter(reinterpret_cast<const ANSICHAR*>(Bytes.GetData()), Bytes.Num());
-		FString AssetName(Converter.Length(), Converter.Get());
 
-		if (ExistingNames.Contains(AssetName))
+		if (bTargetExists)
 		{
 			Result += Html.Mid(Matcher.GetMatchBeginning(), Matcher.GetMatchEnding() - Matcher.GetMatchBeginning());
 		}
 		else
 		{
-			Result += FString::Printf(TEXT("<a class=\"md-broken-link\" href=\"mdasset://%s\""), *EncodedTarget);
+			Result += FString::Printf(TEXT("<a class=\"md-broken-link\" href=\"%s://%s\""), *Scheme, *EncodedTarget);
 		}
 
 		LastPos = Matcher.GetMatchEnding();
@@ -300,7 +379,7 @@ void FMarkdownAssetEditorToolkit::UpdatePreview()
 	if (MarkdownAsset && WebBrowserWidget.IsValid())
 	{
 		FString ParsedHtml = MarkdownAsset->GetParsedHTML();
-		ParsedHtml = MarkBrokenWikilinks(ParsedHtml);
+		ParsedHtml = MarkBrokenLinks(ParsedHtml);
 		FString StyledHtml = GenerateStyledHtml(ParsedHtml);
 
 		// Explicitly convert FString (UTF-16) to UTF-8 bytes before Base64 encoding
@@ -611,15 +690,32 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 	}
 
 	// Handle mdasset:// scheme for wikilinks
-	static const FString Scheme = TEXT("mdasset://");
-	if (Url.StartsWith(Scheme))
+	static const FString MdAssetScheme = TEXT("mdasset://");
+	if (Url.StartsWith(MdAssetScheme))
 	{
-		FString AssetName = Url.Mid(Scheme.Len());
-		AssetName = PercentDecode(AssetName);
+		FString AssetName = PercentDecode(Url.Mid(MdAssetScheme.Len()));
 		OpenLinkedMarkdownAsset(AssetName);
 		return true;
 	}
 
+	// Handle ueasset:// scheme for Content Browser asset / Blueprint object paths
+	static const FString UEAssetScheme = TEXT("ueasset://");
+	if (Url.StartsWith(UEAssetScheme))
+	{
+		FString ObjectPath = PercentDecode(Url.Mid(UEAssetScheme.Len()));
+		OpenLinkedUnrealAsset(ObjectPath);
+		return true;
+	}
+
+	// Handle class:// scheme for C++ or Blueprint class references
+	static const FString ClassScheme = TEXT("class://");
+	if (Url.StartsWith(ClassScheme))
+	{
+		FString ClassName = PercentDecode(Url.Mid(ClassScheme.Len()));
+		OpenLinkedClass(ClassName);
+		return true;
+	}
+
 	// Open external URLs in the system browser
 	if (Url.StartsWith(TEXT("http://")) || Url.StartsWith(TEXT("https://")))
 	{
@@ -657,4 +753,105 @@ void FMarkdownAssetEditorToolkit::OpenLinkedMarkdownAsset(const FString& AssetNa
 	}
 }
 
+void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPath)
+{
+	if (ObjectPath.IsEmpty())
+	{
+		return;
+	}
+
+	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
+	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+
+	// Try the path as provided, then the common "/Game/Foo/Bar.Bar" form.
+	TArray<FString> CandidatePaths;
+	CandidatePaths.Add(ObjectPath);
+
+	int32 SlashIndex;
+	if (!ObjectPath.Contains(TEXT(".")) && ObjectPath.FindLastChar(TEXT('/'), SlashIndex))
+	{
+		const FString LeafName = ObjectPath.Mid(SlashIndex + 1);
+		CandidatePaths.Add(FString::Printf(TEXT("%s.%s"), *ObjectPath, *LeafName));
+	}
+
+	for (const FString& Candidate : CandidatePaths)
+	{
+		const FSoftObjectPath SoftPath(Candidate);
+		FAssetData AssetData = AssetRegistry.GetAssetByObjectPath(SoftPath);
+		if (!AssetData.IsValid())
+		{
+			continue;
+		}
+
+		if (UObject* LoadedAsset = AssetData.GetAsset())
+		{
+			GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OpenEditorForAsset(LoadedAsset);
+			return;
+		}
+	}
+
+	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Asset link target not found: '%s'"), *ObjectPath);
+}
+
+void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
+{
+	if (ClassName.IsEmpty())
+	{
+		return;
+	}
+
+	// Native UClass lookup; try common UE prefixes if the bare name misses.
+	TArray<FString> NativeCandidates = { ClassName };
+	if (!ClassName.StartsWith(TEXT("A")) && !ClassName.StartsWith(TEXT("U")))
+	{
+		NativeCandidates.Add(FString::Printf(TEXT("A%s"), *ClassName));
+		NativeCandidates.Add(FString::Printf(TEXT("U%s"), *ClassName));
+	}
+
+	for (const FString& Candidate : NativeCandidates)
+	{
+		if (UClass* FoundClass = FindFirstObject<UClass>(*Candidate, EFindFirstObjectOptions::NativeFirst))
+		{
+			if (FoundClass->HasAnyClassFlags(CLASS_Native))
+			{
+				if (!FSourceCodeNavigation::NavigateToClass(FoundClass))
+				{
+					UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Failed to open source for native class '%s'"), *FoundClass->GetName());
+				}
+				return;
+			}
+		}
+	}
+
+	// Blueprint class fallback: accept both "BP_Foo" and "BP_Foo_C".
+	FString BlueprintAssetName = ClassName;
+	if (BlueprintAssetName.EndsWith(TEXT("_C")))
+	{
+		BlueprintAssetName.LeftChopInline(2);
+	}
+
+	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
+	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+
+	TArray<FAssetData> BlueprintAssets;
+	AssetRegistry.GetAssetsByClass(UBlueprint::StaticClass()->GetClassPathName(), BlueprintAssets);
+
+	const FAssetData* MatchedBlueprint = BlueprintAssets.FindByPredicate(
+		[&BlueprintAssetName](const FAssetData& Asset)
+		{
+			return Asset.AssetName.ToString() == BlueprintAssetName;
+		});
+
+	if (MatchedBlueprint)
+	{
+		if (UObject* LoadedBlueprint = MatchedBlueprint->GetAsset())
+		{
+			GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OpenEditorForAsset(LoadedBlueprint);
+			return;
+		}
+	}
+
+	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Class link target not found: '%s'"), *ClassName);
+}
+
 #undef LOCTEXT_NAMESPACE
diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Public/MarkdownAssetEditorToolkit.h b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Public/MarkdownAssetEditorToolkit.h
index 5e57015..7c290bb 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Public/MarkdownAssetEditorToolkit.h
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Public/MarkdownAssetEditorToolkit.h
@@ -146,6 +146,12 @@ class FMarkdownAssetEditorToolkit : public FAssetEditorToolkit
 	/** Opens a linked Markdown asset by name via the Asset Registry. */
 	void OpenLinkedMarkdownAsset(const FString& AssetName);
 
+	/** Opens an Unreal asset referenced by a package / object path (e.g. /Game/Path/To/Asset). */
+	void OpenLinkedUnrealAsset(const FString& ObjectPath);
+
+	/** Opens a C++ class in the IDE or a Blueprint class in its asset editor by class name. */
+	void OpenLinkedClass(const FString& ClassName);
+
 	/** Timer handle for debouncing preview updates after text changes. */
 	FTimerHandle PreviewUpdateTimerHandle;
 
diff --git a/README.ja.md b/README.ja.md
index 37125a9..77eada7 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -21,6 +21,7 @@
 - **インポート / エクスポート** — `.md` / `.markdown` ファイルをコンテンツブラウザにドラッグ＆ドロップしてインポート、ソースファイルからのリインポート、および `.md` ファイルへのエクスポートに対応しています。
 - **GitHub Flavored Markdown** — `MD_DIALECT_GITHUB` フラグにより、テーブル、タスクリスト、取り消し線などの GFM 拡張構文をサポートしました。
 - **Wikilink** — `[[アセット名]]` と記述するだけでアセット間リンクを作成できます。プレビュー内のリンクをクリックすると、対象のMarkdownアセットが新しいタブで開きます。存在しないアセットへのリンクは赤色で表示されます。
+- **アセット・クラスリンク** — 標準Markdown構文 `[ラベル](/Game/Path/To/Asset)` でContent Browserのアセット（Blueprintを含む）、`[ラベル](class://クラス名)` でC++またはBlueprintクラスへのリンクを記述できます。クリックすると対応するアセットエディタが開き、C++クラスの場合はIDEでソースファイルが開きます。解決できないリンクは赤色で表示されます。
 - **Blueprint サポート** — Blueprint から `RawMarkdownText` の読み書きと `GetParsedHTML()`、`GetRawMarkdownText()`、`GetPlainText()` の呼び出しが可能です。
 - **ツールバーとキーボードショートカット** — 一般的なMarkdown操作のためのキーボードショートカットを備えた組み込みのフォーマットツールバーを用意しています。
 - **元に戻す / やり直し** — Unreal Editorのトランザクションシステムと統合された完全なUndo/Redoサポート（Ctrl+Z / Ctrl+Y）
diff --git a/README.md b/README.md
index 23f3a67..fcbe296 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,7 @@ An Unreal Engine 5.5+ plugin that adds a custom Markdown asset type with a live-
 - **Import / Export** — Drag-and-drop `.md` / `.markdown` files into the Content Browser to import, reimport from source files, or export assets back to `.md`
 - **GitHub Flavored Markdown** — Supports GFM extensions such as tables, task lists, and strikethrough via the `MD_DIALECT_GITHUB` flag
 - **Wikilinks** — Write `[[AssetName]]` to create inter-asset links; clicking a wikilink in the preview opens the target Markdown asset in a new editor tab. Broken links (pointing to non-existent assets) are highlighted in red
+- **Asset & Class Links** — Use standard Markdown syntax `[Label](/Game/Path/To/Asset)` to link to any Content Browser asset (including Blueprints), and `[Label](class://ClassName)` to link to a C++ or Blueprint class. Clicking opens the target in its asset editor or jumps to the C++ source in your IDE; unresolved targets are highlighted in red
 - **Blueprint Support** — Read/write `RawMarkdownText` and call `GetParsedHTML()`, `GetRawMarkdownText()`, and `GetPlainText()` from Blueprints
 - **Toolbar & Keyboard Shortcuts** — Built-in formatting toolbar with keyboard shortcuts for common Markdown operations
 - **Undo / Redo** — Full undo/redo support integrated with the Unreal Editor transaction system (Ctrl+Z / Ctrl+Y)

From 2d4cc69a58e776c5019e0c16b708c1291956db3f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 17 Apr 2026 11:36:38 +0000
Subject: [PATCH 02/21] Open .cpp instead of .h for native class links

FSourceCodeNavigation::NavigateToClass opens the header by default, but
clicking class://Actor is expected to land in the implementation. Try
FindClassSourcePath + OpenSourceFile first and fall back to the header
only when no .cpp exists (header-only classes / interfaces).

https://claude.ai/code/session_01TNergLaAd33WFGjABwPLpE
---
 .../Private/MarkdownAssetEditorToolkit.cpp            | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index 1f2d3c0..22fdeee 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -814,6 +814,17 @@ void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
 		{
 			if (FoundClass->HasAnyClassFlags(CLASS_Native))
 			{
+				// Prefer the implementation file (.cpp); fall back to the header when no
+				// .cpp is available (header-only classes, interfaces, etc.).
+				FString SourcePath;
+				if (FSourceCodeNavigation::FindClassSourcePath(FoundClass, SourcePath) && !SourcePath.IsEmpty())
+				{
+					if (FSourceCodeNavigation::OpenSourceFile(SourcePath))
+					{
+						return;
+					}
+				}
+
 				if (!FSourceCodeNavigation::NavigateToClass(FoundClass))
 				{
 					UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Failed to open source for native class '%s'"), *FoundClass->GetName());

From d665117a3825d30ef0318a072eae4493bb15a8ea Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 17 Apr 2026 11:58:46 +0000
Subject: [PATCH 03/21] Resolve native class names with A/U/I prefix stripped

UHT strips the leading A/U/I prefix from native class reflection names
(AActor -> "Actor", UObject -> "Object"), so class://AActor previously
failed to resolve and was flagged as a broken link. Extract candidate
generation into BuildClassNameCandidates which both strips and adds
prefixes, letting the detector and opener accept either form.

https://claude.ai/code/session_01TNergLaAd33WFGjABwPLpE
---
 .../Private/MarkdownAssetEditorToolkit.cpp    | 57 +++++++++++++------
 1 file changed, 40 insertions(+), 17 deletions(-)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index 22fdeee..d979525 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -96,6 +96,42 @@ static FString GenerateStyledHtml(const FString& ParsedHtml)
 	), *ParsedHtml);
 }
 
+/**
+ * Builds reflection-name candidates to try when resolving a user-supplied class name.
+ * UHT strips the leading A/U/I prefix from native class names, so "class://AActor"
+ * must be matched against the UClass named "Actor". Conversely, a bare "Actor" may
+ * need to be resolved as "AActor" for a hypothetical class in some projects.
+ */
+static TArray<FString> BuildClassNameCandidates(const FString& ClassName)
+{
+	TArray<FString> Candidates;
+	if (ClassName.IsEmpty())
+	{
+		return Candidates;
+	}
+
+	Candidates.Add(ClassName);
+
+	// Strip a single-letter A/U/I prefix when followed by an uppercase letter.
+	if (ClassName.Len() > 1 && FChar::IsUpper(ClassName[1]))
+	{
+		const TCHAR First = ClassName[0];
+		if (First == TEXT('A') || First == TEXT('U') || First == TEXT('I'))
+		{
+			Candidates.AddUnique(ClassName.Mid(1));
+		}
+	}
+
+	// Add A/U-prefixed variants for bare names.
+	if (FChar::IsUpper(ClassName[0]))
+	{
+		Candidates.AddUnique(FString::Printf(TEXT("A%s"), *ClassName));
+		Candidates.AddUnique(FString::Printf(TEXT("U%s"), *ClassName));
+	}
+
+	return Candidates;
+}
+
 /** Returns true if an Unreal asset exists at the given object path. */
 static bool DoesAssetExistAtPath(const FString& ObjectPath)
 {
@@ -131,14 +167,8 @@ static bool DoesClassExist(const FString& ClassName)
 		return false;
 	}
 
-	// Native class lookup (tries exact name, then common A/U prefixes).
-	TArray<FString> Candidates = { ClassName };
-	if (!ClassName.StartsWith(TEXT("A")) && !ClassName.StartsWith(TEXT("U")))
-	{
-		Candidates.Add(FString::Printf(TEXT("A%s"), *ClassName));
-		Candidates.Add(FString::Printf(TEXT("U%s"), *ClassName));
-	}
-	for (const FString& Candidate : Candidates)
+	// Native class lookup against reflection names (UHT strips A/U/I prefixes).
+	for (const FString& Candidate : BuildClassNameCandidates(ClassName))
 	{
 		if (FindFirstObject<UClass>(*Candidate, EFindFirstObjectOptions::NativeFirst) != nullptr)
 		{
@@ -800,15 +830,8 @@ void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
 		return;
 	}
 
-	// Native UClass lookup; try common UE prefixes if the bare name misses.
-	TArray<FString> NativeCandidates = { ClassName };
-	if (!ClassName.StartsWith(TEXT("A")) && !ClassName.StartsWith(TEXT("U")))
-	{
-		NativeCandidates.Add(FString::Printf(TEXT("A%s"), *ClassName));
-		NativeCandidates.Add(FString::Printf(TEXT("U%s"), *ClassName));
-	}
-
-	for (const FString& Candidate : NativeCandidates)
+	// Native UClass lookup against reflection names (UHT strips A/U/I prefixes).
+	for (const FString& Candidate : BuildClassNameCandidates(ClassName))
 	{
 		if (UClass* FoundClass = FindFirstObject<UClass>(*Candidate, EFindFirstObjectOptions::NativeFirst))
 		{

From 2ce79b71050dd5344d07d98d1ca189aa54552498 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 17 Apr 2026 12:14:02 +0000
Subject: [PATCH 04/21] Preserve path separators in ueasset:// URLs

Previously the full package path was percent-encoded including every
'/', producing URLs like "ueasset://%2FGame%2FFoo%2FBar" with no real
path component. CEF could not parse that as navigable, so clicking a
Blueprint link blanked the preview and the asset never opened. Switch
to a path-aware encoder that leaves '/' literal, yielding well-formed
"ueasset:///Game/Foo/Bar" URLs that reach HandleBeforeNavigation.

https://claude.ai/code/session_01TNergLaAd33WFGjABwPLpE
---
 .../MarkdownAsset/Private/MarkdownAsset.cpp   | 34 ++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAsset/Private/MarkdownAsset.cpp b/Plugins/MarkdownAsset/Source/MarkdownAsset/Private/MarkdownAsset.cpp
index 3a86241..fb73ccc 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAsset/Private/MarkdownAsset.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAsset/Private/MarkdownAsset.cpp
@@ -37,6 +37,36 @@ static FString PercentEncode(const FString& Input)
 	return Encoded;
 }
 
+/**
+ * Percent-encodes a URI path while preserving the path-separator '/' so the result
+ * forms a well-formed scheme:///path URL (e.g. "ueasset:///Game/Foo/Bar"). Encoding
+ * every '/' produced an invalid authority-only URL that CEF failed to navigate.
+ */
+static FString PercentEncodePath(const FString& Input)
+{
+	FTCHARToUTF8 Utf8(*Input);
+	const char* Data = Utf8.Get();
+	int32 Len = Utf8.Length();
+
+	FString Encoded;
+	Encoded.Reserve(Len * 3);
+
+	for (int32 i = 0; i < Len; ++i)
+	{
+		uint8 Ch = static_cast<uint8>(Data[i]);
+		if ((Ch >= 'A' && Ch <= 'Z') || (Ch >= 'a' && Ch <= 'z') || (Ch >= '0' && Ch <= '9')
+			|| Ch == '-' || Ch == '_' || Ch == '.' || Ch == '~' || Ch == '/')
+		{
+			Encoded.AppendChar(static_cast<TCHAR>(Ch));
+		}
+		else
+		{
+			Encoded += FString::Printf(TEXT("%%%02X"), Ch);
+		}
+	}
+	return Encoded;
+}
+
 /**
  * Converts md4c-html wikilink elements to anchor tags with the mdasset:// scheme.
  * Input:  <x-wikilink data-target="Name">Name</x-wikilink>
@@ -117,7 +147,9 @@ static FString PostProcessAssetAndClassLinks(const FString& Html)
 
 		if (bIsPackagePath)
 		{
-			const FString Encoded = PercentEncode(DecodedHref);
+			// Produce "ueasset:///Game/Foo/Bar" (scheme + empty authority + path);
+			// path separators must stay literal for CEF to parse the URL.
+			const FString Encoded = PercentEncodePath(DecodedHref);
 			Processed += FString::Printf(TEXT("<a href=\"ueasset://%s\""), *Encoded);
 		}
 		else if (bIsClassScheme)

From ed2852af95f3d529d2b26bc410e7e8889313ee57 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 17 Apr 2026 12:31:18 +0000
Subject: [PATCH 05/21] Add [LinkDebug] logs to diagnose link navigation

Every <a href> emitted by the preview, the URL received by
HandleBeforeNavigation, and each resolution step inside
OpenLinkedUnrealAsset / OpenLinkedClass now emit Display-level logs in
the LogMarkdownAssetEditor category. Temporary diagnostics for tracking
down why Blueprint link clicks blank the preview.

https://claude.ai/code/session_01TNergLaAd33WFGjABwPLpE
---
 .../Private/MarkdownAssetEditorToolkit.cpp    | 83 ++++++++++++++++---
 1 file changed, 72 insertions(+), 11 deletions(-)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index d979525..037401e 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -410,6 +410,21 @@ void FMarkdownAssetEditorToolkit::UpdatePreview()
 	{
 		FString ParsedHtml = MarkdownAsset->GetParsedHTML();
 		ParsedHtml = MarkBrokenLinks(ParsedHtml);
+
+		// [LinkDebug] Log every <a href="..."> in the rendered HTML so we can see
+		// exactly what the web browser receives for each link.
+		{
+			const FRegexPattern HrefPattern(TEXT("<a[^>]*href=\"([^\"]*)\""));
+			FRegexMatcher HrefMatcher(HrefPattern, ParsedHtml);
+			int32 HrefIndex = 0;
+			while (HrefMatcher.FindNext())
+			{
+				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] rendered href[%d] = '%s'"),
+					HrefIndex++, *HrefMatcher.GetCaptureGroup(1));
+			}
+			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] Preview refresh: %d link(s) emitted"), HrefIndex);
+		}
+
 		FString StyledHtml = GenerateStyledHtml(ParsedHtml);
 
 		// Explicitly convert FString (UTF-16) to UTF-8 bytes before Base64 encoding
@@ -719,11 +734,14 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 		return false;
 	}
 
+	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] HandleBeforeNavigation: Url='%s' (len=%d)"), *Url, Url.Len());
+
 	// Handle mdasset:// scheme for wikilinks
 	static const FString MdAssetScheme = TEXT("mdasset://");
 	if (Url.StartsWith(MdAssetScheme))
 	{
 		FString AssetName = PercentDecode(Url.Mid(MdAssetScheme.Len()));
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] Matched mdasset:// -> AssetName='%s'"), *AssetName);
 		OpenLinkedMarkdownAsset(AssetName);
 		return true;
 	}
@@ -733,6 +751,7 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 	if (Url.StartsWith(UEAssetScheme))
 	{
 		FString ObjectPath = PercentDecode(Url.Mid(UEAssetScheme.Len()));
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] Matched ueasset:// -> ObjectPath='%s'"), *ObjectPath);
 		OpenLinkedUnrealAsset(ObjectPath);
 		return true;
 	}
@@ -742,6 +761,7 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 	if (Url.StartsWith(ClassScheme))
 	{
 		FString ClassName = PercentDecode(Url.Mid(ClassScheme.Len()));
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] Matched class:// -> ClassName='%s'"), *ClassName);
 		OpenLinkedClass(ClassName);
 		return true;
 	}
@@ -749,10 +769,12 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 	// Open external URLs in the system browser
 	if (Url.StartsWith(TEXT("http://")) || Url.StartsWith(TEXT("https://")))
 	{
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] External URL -> launching in system browser"));
 		FPlatformProcess::LaunchURL(*Url, nullptr, nullptr);
 		return true;
 	}
 
+	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] No scheme matched; navigation will be denied (returning false)"));
 	return false;
 }
 
@@ -785,8 +807,11 @@ void FMarkdownAssetEditorToolkit::OpenLinkedMarkdownAsset(const FString& AssetNa
 
 void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPath)
 {
+	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] OpenLinkedUnrealAsset: ObjectPath='%s'"), *ObjectPath);
+
 	if (ObjectPath.IsEmpty())
 	{
+		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] OpenLinkedUnrealAsset: empty path, aborting"));
 		return;
 	}
 
@@ -806,51 +831,77 @@ void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPat
 
 	for (const FString& Candidate : CandidatePaths)
 	{
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   candidate='%s'"), *Candidate);
 		const FSoftObjectPath SoftPath(Candidate);
 		FAssetData AssetData = AssetRegistry.GetAssetByObjectPath(SoftPath);
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   AssetData.IsValid()=%d"), AssetData.IsValid() ? 1 : 0);
 		if (!AssetData.IsValid())
 		{
 			continue;
 		}
 
-		if (UObject* LoadedAsset = AssetData.GetAsset())
+		UObject* LoadedAsset = AssetData.GetAsset();
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   LoadedAsset=%s (class=%s)"),
+			LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"),
+			LoadedAsset ? *LoadedAsset->GetClass()->GetName() : TEXT("n/a"));
+
+		if (LoadedAsset)
 		{
-			GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OpenEditorForAsset(LoadedAsset);
+			UAssetEditorSubsystem* AssetEditorSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr;
+			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   AssetEditorSubsystem=%s"), AssetEditorSubsystem ? TEXT("valid") : TEXT("nullptr"));
+			if (AssetEditorSubsystem)
+			{
+				const bool bOpened = AssetEditorSubsystem->OpenEditorForAsset(LoadedAsset);
+				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   OpenEditorForAsset returned %d"), bOpened ? 1 : 0);
+			}
 			return;
 		}
 	}
 
-	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Asset link target not found: '%s'"), *ObjectPath);
+	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] Asset link target not found: '%s'"), *ObjectPath);
 }
 
 void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
 {
+	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] OpenLinkedClass: ClassName='%s'"), *ClassName);
+
 	if (ClassName.IsEmpty())
 	{
+		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] OpenLinkedClass: empty name, aborting"));
 		return;
 	}
 
 	// Native UClass lookup against reflection names (UHT strips A/U/I prefixes).
 	for (const FString& Candidate : BuildClassNameCandidates(ClassName))
 	{
-		if (UClass* FoundClass = FindFirstObject<UClass>(*Candidate, EFindFirstObjectOptions::NativeFirst))
+		UClass* FoundClass = FindFirstObject<UClass>(*Candidate, EFindFirstObjectOptions::NativeFirst);
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   native candidate='%s' -> %s"),
+			*Candidate, FoundClass ? *FoundClass->GetPathName() : TEXT("(null)"));
+
+		if (FoundClass)
 		{
 			if (FoundClass->HasAnyClassFlags(CLASS_Native))
 			{
 				// Prefer the implementation file (.cpp); fall back to the header when no
 				// .cpp is available (header-only classes, interfaces, etc.).
 				FString SourcePath;
-				if (FSourceCodeNavigation::FindClassSourcePath(FoundClass, SourcePath) && !SourcePath.IsEmpty())
+				const bool bFoundSource = FSourceCodeNavigation::FindClassSourcePath(FoundClass, SourcePath);
+				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   FindClassSourcePath bFound=%d path='%s'"), bFoundSource ? 1 : 0, *SourcePath);
+				if (bFoundSource && !SourcePath.IsEmpty())
 				{
-					if (FSourceCodeNavigation::OpenSourceFile(SourcePath))
+					const bool bOpened = FSourceCodeNavigation::OpenSourceFile(SourcePath);
+					UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   OpenSourceFile returned %d"), bOpened ? 1 : 0);
+					if (bOpened)
 					{
 						return;
 					}
 				}
 
-				if (!FSourceCodeNavigation::NavigateToClass(FoundClass))
+				const bool bNavigated = FSourceCodeNavigation::NavigateToClass(FoundClass);
+				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   NavigateToClass returned %d"), bNavigated ? 1 : 0);
+				if (!bNavigated)
 				{
-					UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Failed to open source for native class '%s'"), *FoundClass->GetName());
+					UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] Failed to open source for native class '%s'"), *FoundClass->GetName());
 				}
 				return;
 			}
@@ -863,12 +914,14 @@ void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
 	{
 		BlueprintAssetName.LeftChopInline(2);
 	}
+	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   blueprint asset name='%s'"), *BlueprintAssetName);
 
 	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
 	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
 
 	TArray<FAssetData> BlueprintAssets;
 	AssetRegistry.GetAssetsByClass(UBlueprint::StaticClass()->GetClassPathName(), BlueprintAssets);
+	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   registry reports %d Blueprint asset(s)"), BlueprintAssets.Num());
 
 	const FAssetData* MatchedBlueprint = BlueprintAssets.FindByPredicate(
 		[&BlueprintAssetName](const FAssetData& Asset)
@@ -878,14 +931,22 @@ void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
 
 	if (MatchedBlueprint)
 	{
-		if (UObject* LoadedBlueprint = MatchedBlueprint->GetAsset())
+		UObject* LoadedBlueprint = MatchedBlueprint->GetAsset();
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   matched BP asset -> %s"),
+			LoadedBlueprint ? *LoadedBlueprint->GetPathName() : TEXT("nullptr"));
+		if (LoadedBlueprint)
 		{
-			GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OpenEditorForAsset(LoadedBlueprint);
+			UAssetEditorSubsystem* AssetEditorSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr;
+			if (AssetEditorSubsystem)
+			{
+				const bool bOpened = AssetEditorSubsystem->OpenEditorForAsset(LoadedBlueprint);
+				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   OpenEditorForAsset returned %d"), bOpened ? 1 : 0);
+			}
 			return;
 		}
 	}
 
-	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Class link target not found: '%s'"), *ClassName);
+	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] Class link target not found: '%s'"), *ClassName);
 }
 
 #undef LOCTEXT_NAMESPACE

From 7374acd22139a0c74196d4c7bb89e5d6ddb444f1 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 17 Apr 2026 13:40:24 +0000
Subject: [PATCH 06/21] Resolve Blueprint assets via package-name lookup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous FSoftObjectPath-based query returned invalid FAssetData for
Blueprint targets even when the asset existed on disk, so clicking a
/Game/... link silently failed. Replace the lookup with a three-tier chain:

1. AssetRegistry::GetAssetsByPackageName — the canonical package-based
   query that reliably hits indexed Content Browser assets.
2. Legacy GetAssetByObjectPath for both raw and dotted forms, preserved
   as a compatibility fallback.
3. StaticLoadObject as a last resort so on-disk packages that have not
   been indexed yet still open.

DoesAssetExistAtPath mirrors the same strategy plus FPackageName::DoesPackageExist
so broken-link highlighting matches runtime resolution.

https://claude.ai/code/session_01TNergLaAd33WFGjABwPLpE
---
 .../Private/MarkdownAssetEditorToolkit.cpp    | 118 ++++++++++++------
 1 file changed, 78 insertions(+), 40 deletions(-)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index 037401e..6553fc6 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -138,25 +138,30 @@ static bool DoesAssetExistAtPath(const FString& ObjectPath)
 	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
 	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
 
-	const FSoftObjectPath SoftPath(ObjectPath);
-	if (AssetRegistry.GetAssetByObjectPath(SoftPath).IsValid())
+	// Strip a trailing ".ObjectName" to derive the package path; the registry indexes by package.
+	FString PackagePath = ObjectPath;
+	int32 DotIndex;
+	if (PackagePath.FindChar(TEXT('.'), DotIndex))
+	{
+		PackagePath.LeftInline(DotIndex);
+	}
+
+	TArray<FAssetData> PackageAssets;
+	AssetRegistry.GetAssetsByPackageName(FName(*PackagePath), PackageAssets);
+	if (PackageAssets.Num() > 0)
 	{
 		return true;
 	}
 
-	// Content Browser paths often omit the trailing ".AssetName"; try appending it.
-	int32 SlashIndex;
-	if (!ObjectPath.Contains(TEXT(".")) && ObjectPath.FindLastChar(TEXT('/'), SlashIndex))
+	// Secondary: legacy object-path query in case the caller supplied a non-package form.
+	if (AssetRegistry.GetAssetByObjectPath(FSoftObjectPath(ObjectPath)).IsValid())
 	{
-		const FString LeafName = ObjectPath.Mid(SlashIndex + 1);
-		const FString FullPath = FString::Printf(TEXT("%s.%s"), *ObjectPath, *LeafName);
-		if (AssetRegistry.GetAssetByObjectPath(FSoftObjectPath(FullPath)).IsValid())
-		{
-			return true;
-		}
+		return true;
 	}
 
-	return false;
+	// Last resort: does the package file exist on disk? Catches assets the registry has not
+	// yet indexed (e.g. newly added plugin content).
+	return FPackageName::DoesPackageExist(PackagePath);
 }
 
 /** Returns true if a native UClass or Blueprint class matching ClassName can be resolved. */
@@ -818,47 +823,80 @@ void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPat
 	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
 	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
 
-	// Try the path as provided, then the common "/Game/Foo/Bar.Bar" form.
-	TArray<FString> CandidatePaths;
-	CandidatePaths.Add(ObjectPath);
+	// Derive the package path (strip any trailing ".ObjectName") and the full object path.
+	FString PackagePath = ObjectPath;
+	int32 DotIndex;
+	if (PackagePath.FindChar(TEXT('.'), DotIndex))
+	{
+		PackagePath.LeftInline(DotIndex);
+	}
 
 	int32 SlashIndex;
-	if (!ObjectPath.Contains(TEXT(".")) && ObjectPath.FindLastChar(TEXT('/'), SlashIndex))
+	FString LeafName;
+	if (PackagePath.FindLastChar(TEXT('/'), SlashIndex))
 	{
-		const FString LeafName = ObjectPath.Mid(SlashIndex + 1);
-		CandidatePaths.Add(FString::Printf(TEXT("%s.%s"), *ObjectPath, *LeafName));
+		LeafName = PackagePath.Mid(SlashIndex + 1);
 	}
+	const FString FullObjectPath = LeafName.IsEmpty() ? ObjectPath : FString::Printf(TEXT("%s.%s"), *PackagePath, *LeafName);
+	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   package='%s' full='%s'"), *PackagePath, *FullObjectPath);
 
-	for (const FString& Candidate : CandidatePaths)
-	{
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   candidate='%s'"), *Candidate);
-		const FSoftObjectPath SoftPath(Candidate);
-		FAssetData AssetData = AssetRegistry.GetAssetByObjectPath(SoftPath);
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   AssetData.IsValid()=%d"), AssetData.IsValid() ? 1 : 0);
-		if (!AssetData.IsValid())
-		{
-			continue;
-		}
+	UObject* LoadedAsset = nullptr;
 
-		UObject* LoadedAsset = AssetData.GetAsset();
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   LoadedAsset=%s (class=%s)"),
-			LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"),
-			LoadedAsset ? *LoadedAsset->GetClass()->GetName() : TEXT("n/a"));
+	// 1) Package-name query — most reliable for standard Content Browser paths.
+	TArray<FAssetData> PackageAssets;
+	AssetRegistry.GetAssetsByPackageName(FName(*PackagePath), PackageAssets);
+	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   GetAssetsByPackageName returned %d"), PackageAssets.Num());
+	if (PackageAssets.Num() > 0)
+	{
+		LoadedAsset = PackageAssets[0].GetAsset();
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   package[0].GetAsset -> %s"),
+			LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
+	}
 
-		if (LoadedAsset)
+	// 2) SoftObjectPath query (legacy fallback) for both raw and dotted forms.
+	if (!LoadedAsset)
+	{
+		for (const FString& Candidate : { ObjectPath, FullObjectPath })
 		{
-			UAssetEditorSubsystem* AssetEditorSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr;
-			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   AssetEditorSubsystem=%s"), AssetEditorSubsystem ? TEXT("valid") : TEXT("nullptr"));
-			if (AssetEditorSubsystem)
+			FAssetData AssetData = AssetRegistry.GetAssetByObjectPath(FSoftObjectPath(Candidate));
+			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   GetAssetByObjectPath('%s') valid=%d"),
+				*Candidate, AssetData.IsValid() ? 1 : 0);
+			if (AssetData.IsValid())
 			{
-				const bool bOpened = AssetEditorSubsystem->OpenEditorForAsset(LoadedAsset);
-				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   OpenEditorForAsset returned %d"), bOpened ? 1 : 0);
+				LoadedAsset = AssetData.GetAsset();
+				if (LoadedAsset) break;
 			}
-			return;
 		}
 	}
 
-	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] Asset link target not found: '%s'"), *ObjectPath);
+	// 3) Direct load as a last resort (forces on-disk packages to load even when
+	//    the registry has not indexed them yet).
+	if (!LoadedAsset)
+	{
+		LoadedAsset = StaticLoadObject(UObject::StaticClass(), nullptr, *FullObjectPath);
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   StaticLoadObject('%s') -> %s"),
+			*FullObjectPath, LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
+	}
+
+	if (!LoadedAsset)
+	{
+		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] Asset link target not found: '%s'"), *ObjectPath);
+		return;
+	}
+
+	// Blueprint assets need their generated class opened if the asset itself is a UBlueprint.
+	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   opening asset of class %s"), *LoadedAsset->GetClass()->GetName());
+
+	UAssetEditorSubsystem* AssetEditorSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr;
+	if (AssetEditorSubsystem)
+	{
+		const bool bOpened = AssetEditorSubsystem->OpenEditorForAsset(LoadedAsset);
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   OpenEditorForAsset returned %d"), bOpened ? 1 : 0);
+	}
+	else
+	{
+		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug]   AssetEditorSubsystem unavailable"));
+	}
 }
 
 void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)

From 70d67e385c9bee07fee94ed137bef5fb14fc1bbc Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 17 Apr 2026 13:56:49 +0000
Subject: [PATCH 07/21] Load assets via registry's canonical path and package
 fallback

The earlier log showed FAssetData::IsValid() returning true for the
Blueprint target while GetAsset() still returned nullptr, so the lookup
silently fell through. Switch to FAssetData::GetSoftObjectPath().TryLoad()
so we use the canonical object path stored in the registry and force a
synchronous load, and add logging for AssetName/PackageName/ClassPath so
we can see which asset the registry actually matched.

Also add a LoadPackage + ForEachObjectWithPackage tier after StaticLoadObject:
when the leaf name inside a package does not match the file name we can
still recover the first real asset contained in the package.

https://claude.ai/code/session_01TNergLaAd33WFGjABwPLpE
---
 .../Private/MarkdownAssetEditorToolkit.cpp    | 52 ++++++++++++++++---
 1 file changed, 46 insertions(+), 6 deletions(-)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index 6553fc6..33fab20 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -24,6 +24,9 @@
 #include "Engine/Blueprint.h"
 #include "UObject/UObjectGlobals.h"
 #include "UObject/SoftObjectPath.h"
+#include "UObject/Package.h"
+#include "UObject/MetaData.h"
+#include "Misc/PackageName.h"
 
 #define LOCTEXT_NAMESPACE "MarkdownAssetEditor"
 
@@ -853,7 +856,9 @@ void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPat
 			LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
 	}
 
-	// 2) SoftObjectPath query (legacy fallback) for both raw and dotted forms.
+	// 2) AssetRegistry lookup — use the canonical path stored in FAssetData and load
+	//    it via FSoftObjectPath::TryLoad (GetAsset() was observed to return nullptr
+	//    in some UE5 builds even when IsValid() reports true).
 	if (!LoadedAsset)
 	{
 		for (const FString& Candidate : { ObjectPath, FullObjectPath })
@@ -861,16 +866,28 @@ void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPat
 			FAssetData AssetData = AssetRegistry.GetAssetByObjectPath(FSoftObjectPath(Candidate));
 			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   GetAssetByObjectPath('%s') valid=%d"),
 				*Candidate, AssetData.IsValid() ? 1 : 0);
-			if (AssetData.IsValid())
+			if (!AssetData.IsValid())
 			{
-				LoadedAsset = AssetData.GetAsset();
-				if (LoadedAsset) break;
+				continue;
 			}
+
+			const FSoftObjectPath Resolved = AssetData.GetSoftObjectPath();
+			UE_LOG(LogMarkdownAssetEditor, Display,
+				TEXT("[LinkDebug]   AssetData: AssetName='%s' PackageName='%s' ClassPath='%s' Resolved='%s'"),
+				*AssetData.AssetName.ToString(),
+				*AssetData.PackageName.ToString(),
+				*AssetData.AssetClassPath.ToString(),
+				*Resolved.ToString());
+
+			LoadedAsset = Resolved.TryLoad();
+			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   Resolved.TryLoad() -> %s"),
+				LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
+			if (LoadedAsset) break;
 		}
 	}
 
-	// 3) Direct load as a last resort (forces on-disk packages to load even when
-	//    the registry has not indexed them yet).
+	// 3) StaticLoadObject — forces on-disk packages to load even when the
+	//    registry has not indexed them yet.
 	if (!LoadedAsset)
 	{
 		LoadedAsset = StaticLoadObject(UObject::StaticClass(), nullptr, *FullObjectPath);
@@ -878,6 +895,29 @@ void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPat
 			*FullObjectPath, LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
 	}
 
+	// 4) LoadPackage as a final fallback — finds the first real asset in the
+	//    package even when the object name inside differs from the package leaf.
+	if (!LoadedAsset && FPackageName::DoesPackageExist(PackagePath))
+	{
+		UPackage* LoadedPackage = LoadPackage(nullptr, *PackagePath, LOAD_None);
+		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   LoadPackage('%s') -> %s"),
+			*PackagePath, LoadedPackage ? *LoadedPackage->GetName() : TEXT("nullptr"));
+		if (LoadedPackage)
+		{
+			ForEachObjectWithPackage(LoadedPackage, [&LoadedAsset](UObject* Obj)
+			{
+				if (Obj && Obj->IsAsset() && !Obj->IsA<UMetaData>())
+				{
+					LoadedAsset = Obj;
+					return false;
+				}
+				return true;
+			}, false);
+			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   ForEachObjectWithPackage -> %s"),
+				LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
+		}
+	}
+
 	if (!LoadedAsset)
 	{
 		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] Asset link target not found: '%s'"), *ObjectPath);

From 1f72a4bb0c63745c16dbf6232bbb4fe3808addd2 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 18 Apr 2026 00:39:31 +0000
Subject: [PATCH 08/21] Release v1.2.0 with asset and class linking

- Promote the Unreleased changelog entry to [1.2.0] - 2026-04-18
- Bump MarkdownAsset.uplugin to VersionName 1.2.0 (Version 3)
- Document the new linking syntax with a dedicated table in both
  README.md and README.ja.md (mdasset://, ueasset://, class://, https://)
- Drop the temporary [LinkDebug] diagnostic logs now that the feature
  is verified; keep Warning-level logs for genuine lookup failures

https://claude.ai/code/session_01TNergLaAd33WFGjABwPLpE
---
 CHANGELOG.md                                  |   4 +-
 Plugins/MarkdownAsset/MarkdownAsset.uplugin   |   4 +-
 .../Private/MarkdownAssetEditorToolkit.cpp    | 141 ++++--------------
 README.ja.md                                  |  15 ++
 README.md                                     |  15 ++
 5 files changed, 65 insertions(+), 114 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ce6974e..0d89fe4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,10 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-04-18
+
 ### Added
 
 - **Asset & Class Links** — Standard Markdown links whose target begins with a UE package root (`/Game/`, `/Engine/`, `/Plugins/`, `/Script/`) are now opened in the corresponding asset editor from the HTML preview
-- **Class Link Scheme** — `[Label](class://ClassName)` resolves the target via UClass lookup; native C++ classes open in the IDE via `FSourceCodeNavigation::NavigateToClass`, Blueprint classes open in the Blueprint editor
+- **Class Link Scheme** — `[Label](class://ClassName)` resolves the target via UClass lookup; native C++ classes open in the IDE via `FSourceCodeNavigation` (preferring the `.cpp` file, falling back to the header), Blueprint classes open in the Blueprint editor
 - **Broken Link Styling for New Schemes** — `ueasset://` and `class://` targets that cannot be resolved are highlighted in red in the preview, matching existing wikilink behavior
 
 ## [1.1.0] - 2026-04-04
diff --git a/Plugins/MarkdownAsset/MarkdownAsset.uplugin b/Plugins/MarkdownAsset/MarkdownAsset.uplugin
index fcf7350..8fc4da9 100644
--- a/Plugins/MarkdownAsset/MarkdownAsset.uplugin
+++ b/Plugins/MarkdownAsset/MarkdownAsset.uplugin
@@ -1,7 +1,7 @@
 {
 	"FileVersion": 3,
-	"Version": 2,
-	"VersionName": "1.1.0",
+	"Version": 3,
+	"VersionName": "1.2.0",
 	"FriendlyName": "MarkdownAsset",
 	"Description": "A custom Markdown asset type with a split-pane live preview editor. Supports GFM (tables, task lists, strikethrough). Import/export .md files directly from Content Browser.",
 	"Category": "Editor",
diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index 33fab20..4cebdcc 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -419,20 +419,6 @@ void FMarkdownAssetEditorToolkit::UpdatePreview()
 		FString ParsedHtml = MarkdownAsset->GetParsedHTML();
 		ParsedHtml = MarkBrokenLinks(ParsedHtml);
 
-		// [LinkDebug] Log every <a href="..."> in the rendered HTML so we can see
-		// exactly what the web browser receives for each link.
-		{
-			const FRegexPattern HrefPattern(TEXT("<a[^>]*href=\"([^\"]*)\""));
-			FRegexMatcher HrefMatcher(HrefPattern, ParsedHtml);
-			int32 HrefIndex = 0;
-			while (HrefMatcher.FindNext())
-			{
-				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] rendered href[%d] = '%s'"),
-					HrefIndex++, *HrefMatcher.GetCaptureGroup(1));
-			}
-			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] Preview refresh: %d link(s) emitted"), HrefIndex);
-		}
-
 		FString StyledHtml = GenerateStyledHtml(ParsedHtml);
 
 		// Explicitly convert FString (UTF-16) to UTF-8 bytes before Base64 encoding
@@ -742,14 +728,11 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 		return false;
 	}
 
-	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] HandleBeforeNavigation: Url='%s' (len=%d)"), *Url, Url.Len());
-
 	// Handle mdasset:// scheme for wikilinks
 	static const FString MdAssetScheme = TEXT("mdasset://");
 	if (Url.StartsWith(MdAssetScheme))
 	{
 		FString AssetName = PercentDecode(Url.Mid(MdAssetScheme.Len()));
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] Matched mdasset:// -> AssetName='%s'"), *AssetName);
 		OpenLinkedMarkdownAsset(AssetName);
 		return true;
 	}
@@ -759,7 +742,6 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 	if (Url.StartsWith(UEAssetScheme))
 	{
 		FString ObjectPath = PercentDecode(Url.Mid(UEAssetScheme.Len()));
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] Matched ueasset:// -> ObjectPath='%s'"), *ObjectPath);
 		OpenLinkedUnrealAsset(ObjectPath);
 		return true;
 	}
@@ -769,7 +751,6 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 	if (Url.StartsWith(ClassScheme))
 	{
 		FString ClassName = PercentDecode(Url.Mid(ClassScheme.Len()));
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] Matched class:// -> ClassName='%s'"), *ClassName);
 		OpenLinkedClass(ClassName);
 		return true;
 	}
@@ -777,12 +758,10 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 	// Open external URLs in the system browser
 	if (Url.StartsWith(TEXT("http://")) || Url.StartsWith(TEXT("https://")))
 	{
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] External URL -> launching in system browser"));
 		FPlatformProcess::LaunchURL(*Url, nullptr, nullptr);
 		return true;
 	}
 
-	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] No scheme matched; navigation will be denied (returning false)"));
 	return false;
 }
 
@@ -815,11 +794,8 @@ void FMarkdownAssetEditorToolkit::OpenLinkedMarkdownAsset(const FString& AssetNa
 
 void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPath)
 {
-	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] OpenLinkedUnrealAsset: ObjectPath='%s'"), *ObjectPath);
-
 	if (ObjectPath.IsEmpty())
 	{
-		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] OpenLinkedUnrealAsset: empty path, aborting"));
 		return;
 	}
 
@@ -841,68 +817,44 @@ void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPat
 		LeafName = PackagePath.Mid(SlashIndex + 1);
 	}
 	const FString FullObjectPath = LeafName.IsEmpty() ? ObjectPath : FString::Printf(TEXT("%s.%s"), *PackagePath, *LeafName);
-	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   package='%s' full='%s'"), *PackagePath, *FullObjectPath);
 
 	UObject* LoadedAsset = nullptr;
 
-	// 1) Package-name query — most reliable for standard Content Browser paths.
+	// Package-name query hits the registry's primary index and is the most reliable
+	// path for standard Content Browser assets.
 	TArray<FAssetData> PackageAssets;
 	AssetRegistry.GetAssetsByPackageName(FName(*PackagePath), PackageAssets);
-	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   GetAssetsByPackageName returned %d"), PackageAssets.Num());
 	if (PackageAssets.Num() > 0)
 	{
 		LoadedAsset = PackageAssets[0].GetAsset();
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   package[0].GetAsset -> %s"),
-			LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
 	}
 
-	// 2) AssetRegistry lookup — use the canonical path stored in FAssetData and load
-	//    it via FSoftObjectPath::TryLoad (GetAsset() was observed to return nullptr
-	//    in some UE5 builds even when IsValid() reports true).
+	// GetAsset() has been observed to return nullptr on some UE5 builds despite
+	// IsValid() reporting true. Fall back to loading the canonical path directly.
 	if (!LoadedAsset)
 	{
 		for (const FString& Candidate : { ObjectPath, FullObjectPath })
 		{
 			FAssetData AssetData = AssetRegistry.GetAssetByObjectPath(FSoftObjectPath(Candidate));
-			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   GetAssetByObjectPath('%s') valid=%d"),
-				*Candidate, AssetData.IsValid() ? 1 : 0);
-			if (!AssetData.IsValid())
+			if (AssetData.IsValid())
 			{
-				continue;
+				LoadedAsset = AssetData.GetSoftObjectPath().TryLoad();
+				if (LoadedAsset) break;
 			}
-
-			const FSoftObjectPath Resolved = AssetData.GetSoftObjectPath();
-			UE_LOG(LogMarkdownAssetEditor, Display,
-				TEXT("[LinkDebug]   AssetData: AssetName='%s' PackageName='%s' ClassPath='%s' Resolved='%s'"),
-				*AssetData.AssetName.ToString(),
-				*AssetData.PackageName.ToString(),
-				*AssetData.AssetClassPath.ToString(),
-				*Resolved.ToString());
-
-			LoadedAsset = Resolved.TryLoad();
-			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   Resolved.TryLoad() -> %s"),
-				LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
-			if (LoadedAsset) break;
 		}
 	}
 
-	// 3) StaticLoadObject — forces on-disk packages to load even when the
-	//    registry has not indexed them yet.
+	// StaticLoadObject picks up packages that have not been indexed yet.
 	if (!LoadedAsset)
 	{
 		LoadedAsset = StaticLoadObject(UObject::StaticClass(), nullptr, *FullObjectPath);
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   StaticLoadObject('%s') -> %s"),
-			*FullObjectPath, LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
 	}
 
-	// 4) LoadPackage as a final fallback — finds the first real asset in the
-	//    package even when the object name inside differs from the package leaf.
+	// Last-resort package load so we can locate the first asset even when the
+	// object name inside the package differs from the package leaf.
 	if (!LoadedAsset && FPackageName::DoesPackageExist(PackagePath))
 	{
-		UPackage* LoadedPackage = LoadPackage(nullptr, *PackagePath, LOAD_None);
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   LoadPackage('%s') -> %s"),
-			*PackagePath, LoadedPackage ? *LoadedPackage->GetName() : TEXT("nullptr"));
-		if (LoadedPackage)
+		if (UPackage* LoadedPackage = LoadPackage(nullptr, *PackagePath, LOAD_None))
 		{
 			ForEachObjectWithPackage(LoadedPackage, [&LoadedAsset](UObject* Obj)
 			{
@@ -913,39 +865,25 @@ void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPat
 				}
 				return true;
 			}, false);
-			UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   ForEachObjectWithPackage -> %s"),
-				LoadedAsset ? *LoadedAsset->GetPathName() : TEXT("nullptr"));
 		}
 	}
 
 	if (!LoadedAsset)
 	{
-		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] Asset link target not found: '%s'"), *ObjectPath);
+		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Asset link target not found: '%s'"), *ObjectPath);
 		return;
 	}
 
-	// Blueprint assets need their generated class opened if the asset itself is a UBlueprint.
-	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   opening asset of class %s"), *LoadedAsset->GetClass()->GetName());
-
-	UAssetEditorSubsystem* AssetEditorSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr;
-	if (AssetEditorSubsystem)
+	if (UAssetEditorSubsystem* AssetEditorSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr)
 	{
-		const bool bOpened = AssetEditorSubsystem->OpenEditorForAsset(LoadedAsset);
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   OpenEditorForAsset returned %d"), bOpened ? 1 : 0);
-	}
-	else
-	{
-		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug]   AssetEditorSubsystem unavailable"));
+		AssetEditorSubsystem->OpenEditorForAsset(LoadedAsset);
 	}
 }
 
 void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
 {
-	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug] OpenLinkedClass: ClassName='%s'"), *ClassName);
-
 	if (ClassName.IsEmpty())
 	{
-		UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] OpenLinkedClass: empty name, aborting"));
 		return;
 	}
 
@@ -953,36 +891,24 @@ void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
 	for (const FString& Candidate : BuildClassNameCandidates(ClassName))
 	{
 		UClass* FoundClass = FindFirstObject<UClass>(*Candidate, EFindFirstObjectOptions::NativeFirst);
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   native candidate='%s' -> %s"),
-			*Candidate, FoundClass ? *FoundClass->GetPathName() : TEXT("(null)"));
-
-		if (FoundClass)
+		if (FoundClass && FoundClass->HasAnyClassFlags(CLASS_Native))
 		{
-			if (FoundClass->HasAnyClassFlags(CLASS_Native))
+			// Prefer the implementation file (.cpp); fall back to the header when no
+			// .cpp is available (header-only classes, interfaces, etc.).
+			FString SourcePath;
+			if (FSourceCodeNavigation::FindClassSourcePath(FoundClass, SourcePath) && !SourcePath.IsEmpty())
 			{
-				// Prefer the implementation file (.cpp); fall back to the header when no
-				// .cpp is available (header-only classes, interfaces, etc.).
-				FString SourcePath;
-				const bool bFoundSource = FSourceCodeNavigation::FindClassSourcePath(FoundClass, SourcePath);
-				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   FindClassSourcePath bFound=%d path='%s'"), bFoundSource ? 1 : 0, *SourcePath);
-				if (bFoundSource && !SourcePath.IsEmpty())
+				if (FSourceCodeNavigation::OpenSourceFile(SourcePath))
 				{
-					const bool bOpened = FSourceCodeNavigation::OpenSourceFile(SourcePath);
-					UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   OpenSourceFile returned %d"), bOpened ? 1 : 0);
-					if (bOpened)
-					{
-						return;
-					}
+					return;
 				}
+			}
 
-				const bool bNavigated = FSourceCodeNavigation::NavigateToClass(FoundClass);
-				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   NavigateToClass returned %d"), bNavigated ? 1 : 0);
-				if (!bNavigated)
-				{
-					UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] Failed to open source for native class '%s'"), *FoundClass->GetName());
-				}
-				return;
+			if (!FSourceCodeNavigation::NavigateToClass(FoundClass))
+			{
+				UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Failed to open source for native class '%s'"), *FoundClass->GetName());
 			}
+			return;
 		}
 	}
 
@@ -992,14 +918,12 @@ void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
 	{
 		BlueprintAssetName.LeftChopInline(2);
 	}
-	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   blueprint asset name='%s'"), *BlueprintAssetName);
 
 	FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
 	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
 
 	TArray<FAssetData> BlueprintAssets;
 	AssetRegistry.GetAssetsByClass(UBlueprint::StaticClass()->GetClassPathName(), BlueprintAssets);
-	UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   registry reports %d Blueprint asset(s)"), BlueprintAssets.Num());
 
 	const FAssetData* MatchedBlueprint = BlueprintAssets.FindByPredicate(
 		[&BlueprintAssetName](const FAssetData& Asset)
@@ -1009,22 +933,17 @@ void FMarkdownAssetEditorToolkit::OpenLinkedClass(const FString& ClassName)
 
 	if (MatchedBlueprint)
 	{
-		UObject* LoadedBlueprint = MatchedBlueprint->GetAsset();
-		UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   matched BP asset -> %s"),
-			LoadedBlueprint ? *LoadedBlueprint->GetPathName() : TEXT("nullptr"));
-		if (LoadedBlueprint)
+		if (UObject* LoadedBlueprint = MatchedBlueprint->GetAsset())
 		{
-			UAssetEditorSubsystem* AssetEditorSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr;
-			if (AssetEditorSubsystem)
+			if (UAssetEditorSubsystem* AssetEditorSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr)
 			{
-				const bool bOpened = AssetEditorSubsystem->OpenEditorForAsset(LoadedBlueprint);
-				UE_LOG(LogMarkdownAssetEditor, Display, TEXT("[LinkDebug]   OpenEditorForAsset returned %d"), bOpened ? 1 : 0);
+				AssetEditorSubsystem->OpenEditorForAsset(LoadedBlueprint);
 			}
 			return;
 		}
 	}
 
-	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("[LinkDebug] Class link target not found: '%s'"), *ClassName);
+	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Class link target not found: '%s'"), *ClassName);
 }
 
 #undef LOCTEXT_NAMESPACE
diff --git a/README.ja.md b/README.ja.md
index 77eada7..b9ae592 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -82,6 +82,21 @@
 - **リインポート**: インポートしたアセットを右クリックし、**Reimport** を選択すると元のソースファイルから再読み込みできます。
 - **エクスポート**: Markdownアセットを右クリックし、**Asset Actions > Export** を選択すると `.md` ファイルとして保存できます。
 
+### リンク構文
+
+Markdownアセットは他のMarkdownノート、Content Browserアセット、Blueprint、C++クラスへクロスリンクできます。ライブプレビューでリンクをクリックすると対象が開きます:
+
+| 構文 | 対象 | 開かれるもの |
+|------|------|-------------|
+| `[[ノート名]]` | 他の `UMarkdownAsset` | Markdownエディタタブ |
+| `[ラベル](/Game/Path/To/Asset)` | Content Browserの任意のアセット | アセットエディタ |
+| `[ラベル](/Engine/BasicShapes/Cube)` | Engine同梱アセット | アセットエディタ |
+| `[ラベル](class://クラス名)` | ネイティブC++クラス | IDEのソースファイル（`.cpp` 優先、`.h` フォールバック） |
+| `[ラベル](class://BP_MyActor)` | Blueprintクラス | Blueprintエディタ |
+| `[ラベル](https://...)` | 外部URL | システムブラウザ |
+
+Unrealアセットリンクとして認識されるパスルート: `/Game/`, `/Engine/`, `/Plugins/`, `/Script/`。クラス名はUHTのリフレクション名と照合されるため、プレフィックス付き (`AActor`) と除去済み (`Actor`) の両形式が正しく解決されます。解決できない対象は赤色で表示されます。
+
 ### Blueprint ノード
 
 `UMarkdownAsset` は以下の Blueprint から呼び出し可能な関数を公開しています:
diff --git a/README.md b/README.md
index fcbe296..37b571d 100644
--- a/README.md
+++ b/README.md
@@ -82,6 +82,21 @@ An Unreal Engine 5.5+ plugin that adds a custom Markdown asset type with a live-
 - **Reimport**: Right-click an imported asset and select **Reimport** to reload from the original source file.
 - **Export**: Right-click a Markdown asset and select **Asset Actions > Export** to save it as a `.md` file.
 
+### Linking Syntax
+
+Markdown assets can cross-link to other Markdown notes, Content Browser assets, Blueprints, and C++ classes. Clicking any of the links below in the live preview jumps to the target:
+
+| Syntax | Target | Opens |
+|--------|--------|-------|
+| `[[NoteName]]` | Another `UMarkdownAsset` | Markdown editor tab |
+| `[Label](/Game/Path/To/Asset)` | Any Content Browser asset | Asset editor |
+| `[Label](/Engine/BasicShapes/Cube)` | Engine-bundled asset | Asset editor |
+| `[Label](class://ClassName)` | Native C++ class | IDE source file (`.cpp` preferred, `.h` fallback) |
+| `[Label](class://BP_MyActor)` | Blueprint class | Blueprint editor |
+| `[Label](https://...)` | External URL | System browser |
+
+Path roots recognised as Unreal asset links: `/Game/`, `/Engine/`, `/Plugins/`, `/Script/`. Class names are matched against UHT reflection names, so both prefixed forms (`AActor`) and stripped forms (`Actor`) resolve correctly. Targets that cannot be resolved are rendered in red.
+
 ### Blueprint Nodes
 
 `UMarkdownAsset` exposes the following Blueprint-callable functions:

From 72397b1ccae24963f0bff94f26383e5b7a40ee65 Mon Sep 17 00:00:00 2001
From: EmbarrassingMoment
 <96903403+EmbarrassingMoment@users.noreply.github.com>
Date: Sat, 18 Apr 2026 09:44:40 +0900
Subject: [PATCH 09/21] Add new samples  for v1.2.0

---
 Content/BP_LinkTest.uasset | Bin 0 -> 23414 bytes
 Content/MD_LinkTest.uasset | Bin 0 -> 4056 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 Content/BP_LinkTest.uasset
 create mode 100644 Content/MD_LinkTest.uasset

diff --git a/Content/BP_LinkTest.uasset b/Content/BP_LinkTest.uasset
new file mode 100644
index 0000000000000000000000000000000000000000..d4f519b1a3003ded350dad64c132213bb92c9e12
GIT binary patch
literal 23414
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
R#bu2XAAMjU#ytw~{}*oQU0(nI

literal 0
HcmV?d00001

diff --git a/Content/MD_LinkTest.uasset b/Content/MD_LinkTest.uasset
new file mode 100644
index 0000000000000000000000000000000000000000..20193f7ed764dd1543b43b8e67b5525cc5370e5e
GIT binary patch
literal 4056
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
KF;gTS(f<pfLiSSt

literal 0
HcmV?d00001


From c10ffa33bfa9cf8a7178e8de38bb736fd6a964df Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 10:10:21 +0000
Subject: [PATCH 10/21] Guard UMetaData filter for UE 5.6+ build

UE 5.6 removed UMetaData (UObject) in favor of FMetaData (struct),
so the IsA<UMetaData>() filter no longer compiles. Wrap the include
and check with UE_VERSION_OLDER_THAN(5, 6, 0) to keep 5.5 support.

https://claude.ai/code/session_01844YrCL6CQoEydz2kt476F
---
 .../Private/MarkdownAssetEditorToolkit.cpp               | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index 4cebdcc..3b36da6 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -25,7 +25,10 @@
 #include "UObject/UObjectGlobals.h"
 #include "UObject/SoftObjectPath.h"
 #include "UObject/Package.h"
+#include "Misc/EngineVersionComparison.h"
+#if UE_VERSION_OLDER_THAN(5, 6, 0)
 #include "UObject/MetaData.h"
+#endif
 #include "Misc/PackageName.h"
 
 #define LOCTEXT_NAMESPACE "MarkdownAssetEditor"
@@ -858,7 +861,11 @@ void FMarkdownAssetEditorToolkit::OpenLinkedUnrealAsset(const FString& ObjectPat
 		{
 			ForEachObjectWithPackage(LoadedPackage, [&LoadedAsset](UObject* Obj)
 			{
-				if (Obj && Obj->IsAsset() && !Obj->IsA<UMetaData>())
+				if (Obj && Obj->IsAsset()
+#if UE_VERSION_OLDER_THAN(5, 6, 0)
+					&& !Obj->IsA<UMetaData>()
+#endif
+					)
 				{
 					LoadedAsset = Obj;
 					return false;

From 888e517939ab2ae900dc39a185f574e6d6cab5b5 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 11:14:11 +0000
Subject: [PATCH 11/21] Block unknown URL schemes in preview navigation

Default-deny any scheme that is not explicitly recognized
(data:, about:, mdasset://, ueasset://, class://, http(s)://).
md4c-html does not sanitize URL schemes, so a crafted link such as
[click](javascript:...) would previously execute script in the
preview WebBrowser when clicked, allowing exfiltration of rendered
content via fetch() or SSRF against localhost services.
---
 .../Private/MarkdownAssetEditorToolkit.cpp               | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index 3b36da6..1912abf 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -725,8 +725,8 @@ TSharedRef<SDockTab> FMarkdownAssetEditorToolkit::SpawnTab_Main(const FSpawnTabA
 
 bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, const FWebNavigationRequest& Request)
 {
-	// Allow data: URLs for preview loading
-	if (Url.StartsWith(TEXT("data:")))
+	// Allow data: URLs for preview loading, and about:blank used by CEF during init.
+	if (Url.StartsWith(TEXT("data:")) || Url.StartsWith(TEXT("about:")))
 	{
 		return false;
 	}
@@ -765,7 +765,10 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 		return true;
 	}
 
-	return false;
+	// Default-deny: block unknown schemes (javascript:, file:, vbscript:, etc.)
+	// to prevent script execution or local-file access from untrusted Markdown.
+	UE_LOG(LogMarkdownAssetEditor, Warning, TEXT("Blocked navigation to unsupported URL: '%s'"), *Url);
+	return true;
 }
 
 void FMarkdownAssetEditorToolkit::OpenLinkedMarkdownAsset(const FString& AssetName)

From b0a994c3e2677eef0f673ddfe97ec35b2400486e Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 11:16:32 +0000
Subject: [PATCH 12/21] Update Security section in README to document URL
 scheme allowlist

Document that the preview browser's navigation handler now uses a
strict allowlist and blocks unknown schemes such as javascript: and
file: to prevent script execution from untrusted Markdown content.
---
 README.ja.md | 2 +-
 README.md    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.ja.md b/README.ja.md
index b9ae592..9e0592b 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -25,7 +25,7 @@
 - **Blueprint サポート** — Blueprint から `RawMarkdownText` の読み書きと `GetParsedHTML()`、`GetRawMarkdownText()`、`GetPlainText()` の呼び出しが可能です。
 - **ツールバーとキーボードショートカット** — 一般的なMarkdown操作のためのキーボードショートカットを備えた組み込みのフォーマットツールバーを用意しています。
 - **元に戻す / やり直し** — Unreal Editorのトランザクションシステムと統合された完全なUndo/Redoサポート（Ctrl+Z / Ctrl+Y）
-- **セキュリティ** — ユーザー提供のMarkdownレンダリング時のXSSを防止するため、生のHTMLブロックおよびインラインHTMLはデフォルトで無効化しています。
+- **セキュリティ** — ユーザー提供のMarkdownレンダリング時のXSSを防止するため、生のHTMLブロックおよびインラインHTMLはデフォルトで無効化しています。また、プレビューブラウザのナビゲーションはホワイトリスト方式を採用しており、`data:`・`about:`・`mdasset://`・`ueasset://`・`class://`・`http(s)://` のみを許可し、`javascript:` や `file:` などの未知スキームをブロックすることで、信頼できないMarkdownによるスクリプト実行やローカルファイルアクセスを防いでいます。
 - **ローカライズ** — エディタUIは英語と日本語に対応しています。
 - **ニバイト文字対応** — 日本語などのニバイト文字を含むMarkdownテキストを正しく処理・表示できます。
 
diff --git a/README.md b/README.md
index 37b571d..8ea9686 100644
--- a/README.md
+++ b/README.md
@@ -26,7 +26,7 @@ An Unreal Engine 5.5+ plugin that adds a custom Markdown asset type with a live-
 - **Blueprint Support** — Read/write `RawMarkdownText` and call `GetParsedHTML()`, `GetRawMarkdownText()`, and `GetPlainText()` from Blueprints
 - **Toolbar & Keyboard Shortcuts** — Built-in formatting toolbar with keyboard shortcuts for common Markdown operations
 - **Undo / Redo** — Full undo/redo support integrated with the Unreal Editor transaction system (Ctrl+Z / Ctrl+Y)
-- **Security** — Raw HTML blocks and inline HTML are disabled by default to prevent XSS when rendering user-supplied Markdown
+- **Security** — Raw HTML blocks and inline HTML are disabled by default to prevent XSS when rendering user-supplied Markdown. The preview browser's navigation handler uses a strict allowlist — only `data:`, `about:`, `mdasset://`, `ueasset://`, `class://`, and `http(s)://` are permitted; unknown schemes such as `javascript:` and `file:` are blocked to prevent script execution or local file access from untrusted Markdown content
 - **Localization** — Editor UI is fully localized for English and Japanese
 
 ![Dark Theme Preview](docs/images/dark-theme-preview.png)

From 32efe3cf7263deb68d4fb07d69ec66b20f688ad8 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 11:18:18 +0000
Subject: [PATCH 13/21] Add Content-Security-Policy to preview HTML to block
 external requests

Injects a CSP meta tag that allows only inline styles and data: URIs
for images, blocking all other network requests (scripts, external
images, fetch/XHR, frames). This prevents SSRF against localhost
services and IP/UA tracking via image pixels embedded in untrusted
Markdown assets.
---
 .../MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp  | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index 1912abf..8ddaba7 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -76,6 +76,8 @@ static FString GenerateStyledHtml(const FString& ParsedHtml)
 		"<!DOCTYPE html>\n"
 		"<html><head>\n"
 		"<meta charset=\"utf-8\">\n"
+		"<meta http-equiv=\"Content-Security-Policy\""
+		" content=\"default-src 'none'; style-src 'unsafe-inline'; img-src data:;\">\n"
 		"<style>\n"
 		"body { font-family: 'Segoe UI', 'Meiryo', 'Yu Gothic', sans-serif; background-color: #1e1e1e; color: #cccccc; padding: 20px; }\n"
 		"h1, h2, h3, h4, h5, h6 { color: #ffffff; border-bottom: 1px solid #444; padding-bottom: 5px; }\n"

From 64a3130b34bb1000663136b561f0f0b00a31aabd Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 11:21:46 +0000
Subject: [PATCH 14/21] Update Security section in README to document CSP
 injection

Document that a Content-Security-Policy header is now injected into
every preview page, blocking external network requests to prevent IP
tracking and SSRF against local services.
---
 README.ja.md | 2 +-
 README.md    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.ja.md b/README.ja.md
index 9e0592b..7e5b99f 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -25,7 +25,7 @@
 - **Blueprint サポート** — Blueprint から `RawMarkdownText` の読み書きと `GetParsedHTML()`、`GetRawMarkdownText()`、`GetPlainText()` の呼び出しが可能です。
 - **ツールバーとキーボードショートカット** — 一般的なMarkdown操作のためのキーボードショートカットを備えた組み込みのフォーマットツールバーを用意しています。
 - **元に戻す / やり直し** — Unreal Editorのトランザクションシステムと統合された完全なUndo/Redoサポート（Ctrl+Z / Ctrl+Y）
-- **セキュリティ** — ユーザー提供のMarkdownレンダリング時のXSSを防止するため、生のHTMLブロックおよびインラインHTMLはデフォルトで無効化しています。また、プレビューブラウザのナビゲーションはホワイトリスト方式を採用しており、`data:`・`about:`・`mdasset://`・`ueasset://`・`class://`・`http(s)://` のみを許可し、`javascript:` や `file:` などの未知スキームをブロックすることで、信頼できないMarkdownによるスクリプト実行やローカルファイルアクセスを防いでいます。
+- **セキュリティ** — ユーザー提供のMarkdownレンダリング時のXSSを防止するため、生のHTMLブロックおよびインラインHTMLはデフォルトで無効化しています。また、プレビューブラウザのナビゲーションはホワイトリスト方式を採用しており、`data:`・`about:`・`mdasset://`・`ueasset://`・`class://`・`http(s)://` のみを許可し、`javascript:` や `file:` などの未知スキームをブロックすることで、信頼できないMarkdownによるスクリプト実行やローカルファイルアクセスを防いでいます。さらに、プレビューページには `Content-Security-Policy`（`default-src 'none'; style-src 'unsafe-inline'; img-src data:`）を注入し、外部ネットワークへのリクエスト（外部画像・fetch/XHR・フレーム等）をブロックすることで、IP追跡やローカルサービスへのSSRFを防止しています。
 - **ローカライズ** — エディタUIは英語と日本語に対応しています。
 - **ニバイト文字対応** — 日本語などのニバイト文字を含むMarkdownテキストを正しく処理・表示できます。
 
diff --git a/README.md b/README.md
index 8ea9686..4757d17 100644
--- a/README.md
+++ b/README.md
@@ -26,7 +26,7 @@ An Unreal Engine 5.5+ plugin that adds a custom Markdown asset type with a live-
 - **Blueprint Support** — Read/write `RawMarkdownText` and call `GetParsedHTML()`, `GetRawMarkdownText()`, and `GetPlainText()` from Blueprints
 - **Toolbar & Keyboard Shortcuts** — Built-in formatting toolbar with keyboard shortcuts for common Markdown operations
 - **Undo / Redo** — Full undo/redo support integrated with the Unreal Editor transaction system (Ctrl+Z / Ctrl+Y)
-- **Security** — Raw HTML blocks and inline HTML are disabled by default to prevent XSS when rendering user-supplied Markdown. The preview browser's navigation handler uses a strict allowlist — only `data:`, `about:`, `mdasset://`, `ueasset://`, `class://`, and `http(s)://` are permitted; unknown schemes such as `javascript:` and `file:` are blocked to prevent script execution or local file access from untrusted Markdown content
+- **Security** — Raw HTML blocks and inline HTML are disabled by default to prevent XSS when rendering user-supplied Markdown. The preview browser's navigation handler uses a strict allowlist — only `data:`, `about:`, `mdasset://`, `ueasset://`, `class://`, and `http(s)://` are permitted; unknown schemes such as `javascript:` and `file:` are blocked to prevent script execution or local file access from untrusted Markdown content. A `Content-Security-Policy` header (`default-src 'none'; style-src 'unsafe-inline'; img-src data:`) is injected into every preview page, blocking external network requests (images, fetch/XHR, frames) to prevent IP tracking and SSRF against local services
 - **Localization** — Editor UI is fully localized for English and Japanese
 
 ![Dark Theme Preview](docs/images/dark-theme-preview.png)

From 255e833d006c92cca58e86c7ad610696b059d6ed Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 11:34:19 +0000
Subject: [PATCH 15/21] Prompt for confirmation before launching external URLs

The preview hides the address bar, so users have no way to inspect a
link's destination before clicking. Always present the full URL in a
Yes/No dialog and only call LaunchURL when the user confirms, to
mitigate phishing via crafted Markdown assets.
---
 .../Private/MarkdownAssetEditorToolkit.cpp    | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index 8ddaba7..c621d6d 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -30,6 +30,7 @@
 #include "UObject/MetaData.h"
 #endif
 #include "Misc/PackageName.h"
+#include "Misc/MessageDialog.h"
 
 #define LOCTEXT_NAMESPACE "MarkdownAssetEditor"
 
@@ -760,10 +761,24 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 		return true;
 	}
 
-	// Open external URLs in the system browser
+	// Open external URLs in the system browser after user confirmation.
+	// The preview has no address bar, so we always prompt with the full URL
+	// to let the user inspect it before launching (phishing mitigation).
 	if (Url.StartsWith(TEXT("http://")) || Url.StartsWith(TEXT("https://")))
 	{
-		FPlatformProcess::LaunchURL(*Url, nullptr, nullptr);
+		const FText Message = FText::Format(
+			LOCTEXT("ConfirmExternalUrlMessage", "Open this URL in your default browser?\n\n{0}"),
+			FText::FromString(Url)
+		);
+		const EAppReturnType::Type Response = FMessageDialog::Open(
+			EAppMsgType::YesNo,
+			Message,
+			LOCTEXT("ConfirmExternalUrlTitle", "Open External URL")
+		);
+		if (Response == EAppReturnType::Yes)
+		{
+			FPlatformProcess::LaunchURL(*Url, nullptr, nullptr);
+		}
 		return true;
 	}
 

From 20895f7cc4c79de39d3ee1d3baa204a3274378a1 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 11:36:22 +0000
Subject: [PATCH 16/21] Document external URL confirmation dialog in README

Note that http(s):// links now always prompt for confirmation
before launching in the system browser, as a phishing mitigation
for the preview which has no address bar.
---
 README.ja.md | 2 +-
 README.md    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.ja.md b/README.ja.md
index 7e5b99f..a153e86 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -25,7 +25,7 @@
 - **Blueprint サポート** — Blueprint から `RawMarkdownText` の読み書きと `GetParsedHTML()`、`GetRawMarkdownText()`、`GetPlainText()` の呼び出しが可能です。
 - **ツールバーとキーボードショートカット** — 一般的なMarkdown操作のためのキーボードショートカットを備えた組み込みのフォーマットツールバーを用意しています。
 - **元に戻す / やり直し** — Unreal Editorのトランザクションシステムと統合された完全なUndo/Redoサポート（Ctrl+Z / Ctrl+Y）
-- **セキュリティ** — ユーザー提供のMarkdownレンダリング時のXSSを防止するため、生のHTMLブロックおよびインラインHTMLはデフォルトで無効化しています。また、プレビューブラウザのナビゲーションはホワイトリスト方式を採用しており、`data:`・`about:`・`mdasset://`・`ueasset://`・`class://`・`http(s)://` のみを許可し、`javascript:` や `file:` などの未知スキームをブロックすることで、信頼できないMarkdownによるスクリプト実行やローカルファイルアクセスを防いでいます。さらに、プレビューページには `Content-Security-Policy`（`default-src 'none'; style-src 'unsafe-inline'; img-src data:`）を注入し、外部ネットワークへのリクエスト（外部画像・fetch/XHR・フレーム等）をブロックすることで、IP追跡やローカルサービスへのSSRFを防止しています。
+- **セキュリティ** — ユーザー提供のMarkdownレンダリング時のXSSを防止するため、生のHTMLブロックおよびインラインHTMLはデフォルトで無効化しています。また、プレビューブラウザのナビゲーションはホワイトリスト方式を採用しており、`data:`・`about:`・`mdasset://`・`ueasset://`・`class://`・`http(s)://` のみを許可し、`javascript:` や `file:` などの未知スキームをブロックすることで、信頼できないMarkdownによるスクリプト実行やローカルファイルアクセスを防いでいます。さらに、プレビューページには `Content-Security-Policy`（`default-src 'none'; style-src 'unsafe-inline'; img-src data:`）を注入し、外部ネットワークへのリクエスト（外部画像・fetch/XHR・フレーム等）をブロックすることで、IP追跡やローカルサービスへのSSRFを防止しています。外部 `http(s)://` リンクをクリックした際は必ず確認ダイアログで完全なURLを表示してからシステムブラウザで開くため、細工されたMarkdownアセットによるフィッシングを軽減します。
 - **ローカライズ** — エディタUIは英語と日本語に対応しています。
 - **ニバイト文字対応** — 日本語などのニバイト文字を含むMarkdownテキストを正しく処理・表示できます。
 
diff --git a/README.md b/README.md
index 4757d17..f4eb839 100644
--- a/README.md
+++ b/README.md
@@ -26,7 +26,7 @@ An Unreal Engine 5.5+ plugin that adds a custom Markdown asset type with a live-
 - **Blueprint Support** — Read/write `RawMarkdownText` and call `GetParsedHTML()`, `GetRawMarkdownText()`, and `GetPlainText()` from Blueprints
 - **Toolbar & Keyboard Shortcuts** — Built-in formatting toolbar with keyboard shortcuts for common Markdown operations
 - **Undo / Redo** — Full undo/redo support integrated with the Unreal Editor transaction system (Ctrl+Z / Ctrl+Y)
-- **Security** — Raw HTML blocks and inline HTML are disabled by default to prevent XSS when rendering user-supplied Markdown. The preview browser's navigation handler uses a strict allowlist — only `data:`, `about:`, `mdasset://`, `ueasset://`, `class://`, and `http(s)://` are permitted; unknown schemes such as `javascript:` and `file:` are blocked to prevent script execution or local file access from untrusted Markdown content. A `Content-Security-Policy` header (`default-src 'none'; style-src 'unsafe-inline'; img-src data:`) is injected into every preview page, blocking external network requests (images, fetch/XHR, frames) to prevent IP tracking and SSRF against local services
+- **Security** — Raw HTML blocks and inline HTML are disabled by default to prevent XSS when rendering user-supplied Markdown. The preview browser's navigation handler uses a strict allowlist — only `data:`, `about:`, `mdasset://`, `ueasset://`, `class://`, and `http(s)://` are permitted; unknown schemes such as `javascript:` and `file:` are blocked to prevent script execution or local file access from untrusted Markdown content. A `Content-Security-Policy` header (`default-src 'none'; style-src 'unsafe-inline'; img-src data:`) is injected into every preview page, blocking external network requests (images, fetch/XHR, frames) to prevent IP tracking and SSRF against local services. External `http(s)://` links always prompt a confirmation dialog displaying the full URL before opening in the system browser, mitigating phishing via crafted Markdown assets
 - **Localization** — Editor UI is fully localized for English and Japanese
 
 ![Dark Theme Preview](docs/images/dark-theme-preview.png)

From d828860aa15f744a896b966f1b35c4f2aef0d71a Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 12:08:51 +0000
Subject: [PATCH 17/21] Fix localization Gather SearchDirectoryPaths to actual
 plugin source

The config pointed to Plugins/MarkdownEditor/Source, which no longer
exists after the plugin was renamed to MarkdownAsset. Gather therefore
collected zero source-literal entries. Point it at the real source
tree so LOCTEXT/NSLOCTEXT strings (including the new external-URL
confirmation dialog) are picked up again.
---
 Config/Localization/MarkdownEditor_Gather.ini | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Config/Localization/MarkdownEditor_Gather.ini b/Config/Localization/MarkdownEditor_Gather.ini
index fc34dfd..de26d3b 100644
--- a/Config/Localization/MarkdownEditor_Gather.ini
+++ b/Config/Localization/MarkdownEditor_Gather.ini
@@ -13,7 +13,7 @@ CulturesToGenerate=ja
 
 [GatherTextStep0]
 CommandletClass=GatherTextFromSource
-SearchDirectoryPaths=Plugins/MarkdownEditor/Source
+SearchDirectoryPaths=Plugins/MarkdownAsset/Source
 ExcludePathFilters=Config/Localization/*
 FileNameFilters=*.h
 FileNameFilters=*.cpp

From 66abdf0f2b1c2e4346321337e148b65e3dad6e47 Mon Sep 17 00:00:00 2001
From: EmbarrassingMoment
 <96903403+EmbarrassingMoment@users.noreply.github.com>
Date: Sun, 19 Apr 2026 21:25:40 +0900
Subject: [PATCH 18/21] Update localization.

---
 Config/DefaultEditor.ini                      |   2 +-
 Config/Localization/MarkdownEditor_Gather.ini |   5 ++---
 .../MarkdownEditor/MarkdownEditor.csv         |   4 ++++
 .../MarkdownEditor/MarkdownEditor.manifest    | Bin 24258 -> 25394 bytes
 .../MarkdownEditor/en/MarkdownEditor.archive  | Bin 17070 -> 17966 bytes
 .../MarkdownEditor/en/MarkdownEditor.locres   | Bin 2257 -> 2417 bytes
 .../MarkdownEditor/ja/MarkdownEditor.archive  | Bin 16624 -> 17474 bytes
 .../MarkdownEditor/ja/MarkdownEditor.locres   | Bin 1830 -> 2004 bytes
 8 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/Config/DefaultEditor.ini b/Config/DefaultEditor.ini
index 67bca4f..c41b375 100644
--- a/Config/DefaultEditor.ini
+++ b/Config/DefaultEditor.ini
@@ -14,7 +14,7 @@
 +EngineTargetsSettings=(Name="Keywords",Guid=AE89AECB47475F420D0D69A5547515DC,TargetDependencies=(33482D004789784C9DA695A682ACCA1B,AC8BFD2A41A2FB2893BB8EA0AF903E6D),AdditionalManifestDependencies=,RequiredModuleNames=,GatherFromTextFiles=(IsEnabled=False,SearchDirectories=,ExcludePathWildcards=,FileExtensions=((Pattern="h"),(Pattern="cpp"),(Pattern="ini")),ShouldGatherFromEditorOnlyData=False),GatherFromPackages=(IsEnabled=False,IncludePathWildcards=,ExcludePathWildcards=,FileExtensions=((Pattern="umap"),(Pattern="uasset")),Collections=,ExcludeClasses=,ShouldExcludeDerivedClasses=False,ShouldGatherFromEditorOnlyData=True,SkipGatherCache=False),GatherFromMetaData=(IsEnabled=True,IncludePathWildcards=((Pattern="Source/Editor/*"),(Pattern="Source/Runtime/*"),(Pattern="Source/Developer/*")),ExcludePathWildcards=((Pattern="Source/Developer/NoRedist/CommunityPortalServices/*")),KeySpecifications=((MetaDataKey=(Name="Keywords"),TextNamespace="UObjectKeywords",TextKeyPattern=(Pattern="{FieldPath}"))),FieldTypesToInclude=,FieldTypesToExclude=,FieldOwnerTypesToInclude=,FieldOwnerTypesToExclude=,ShouldGatherFromEditorOnlyData=True),ExportSettings=(CollapseMode=IdenticalTextIdAndSource,POFormat=Unreal,ShouldPersistCommentsOnExport=False,ShouldAddSourceLocationsAsComments=True),CompileSettings=(SkipSourceCheck=False,ValidateFormatPatterns=True,ValidateSafeWhitespace=False),ImportDialogueSettings=(RawAudioPath=(Path=""),ImportedDialogueFolder="ImportedDialogue",bImportNativeAsSource=False),NativeCultureIndex=0,SupportedCulturesStatistics=((CultureName="en"),(CultureName="es"),(CultureName="ja"),(CultureName="ko"),(CultureName="pt-BR"),(CultureName="zh-CN")))
 +EngineTargetsSettings=(Name="Category",Guid=14B8DEE642A6A7AFEB5A28B959EC373A,TargetDependencies=,AdditionalManifestDependencies=,RequiredModuleNames=,GatherFromTextFiles=(IsEnabled=False,SearchDirectories=,ExcludePathWildcards=,FileExtensions=((Pattern="h"),(Pattern="cpp"),(Pattern="ini")),ShouldGatherFromEditorOnlyData=False),GatherFromPackages=(IsEnabled=False,IncludePathWildcards=,ExcludePathWildcards=,FileExtensions=((Pattern="umap"),(Pattern="uasset")),Collections=,ExcludeClasses=,ShouldExcludeDerivedClasses=False,ShouldGatherFromEditorOnlyData=False,SkipGatherCache=False),GatherFromMetaData=(IsEnabled=True,IncludePathWildcards=((Pattern="Source/Editor/*"),(Pattern="Source/Runtime/*"),(Pattern="Source/Developer/*")),ExcludePathWildcards=((Pattern="Source/Developer/NoRedist/CommunityPortalServices/*")),KeySpecifications=((MetaDataKey=(Name="Category"),TextNamespace="UObjectCategory",TextKeyPattern=(Pattern="{FieldPath}"))),FieldTypesToInclude=,FieldTypesToExclude=,FieldOwnerTypesToInclude=,FieldOwnerTypesToExclude=,ShouldGatherFromEditorOnlyData=True),ExportSettings=(CollapseMode=IdenticalTextIdAndSource,POFormat=Unreal,ShouldPersistCommentsOnExport=False,ShouldAddSourceLocationsAsComments=True),CompileSettings=(SkipSourceCheck=False,ValidateFormatPatterns=True,ValidateSafeWhitespace=False),ImportDialogueSettings=(RawAudioPath=(Path=""),ImportedDialogueFolder="ImportedDialogue",bImportNativeAsSource=False),NativeCultureIndex=0,SupportedCulturesStatistics=((CultureName="en"),(CultureName="es"),(CultureName="ja"),(CultureName="ko"),(CultureName="pt-BR"),(CultureName="zh-CN")))
 -GameTargetsSettings=(Name="Game",Guid=AE0EA34A45461A25BA65A391026F19F8,TargetDependencies=(33482D004789784C9DA695A682ACCA1B,AC8BFD2A41A2FB2893BB8EA0AF903E6D),AdditionalManifestDependencies=,RequiredModuleNames=,GatherFromTextFiles=(IsEnabled=False,SearchDirectories=,ExcludePathWildcards=,FileExtensions=((Pattern="h"),(Pattern="cpp"),(Pattern="ini"))),GatherFromPackages=(IsEnabled=False,IncludePathWildcards=,ExcludePathWildcards=,FileExtensions=((Pattern="umap"),(Pattern="uasset")),ShouldGatherFromEditorOnlyData=False),GatherFromMetaData=(IsEnabled=False,IncludePathWildcards=,ExcludePathWildcards=,KeySpecifications=,ShouldGatherFromEditorOnlyData=False),NativeCultureIndex=-1,SupportedCulturesStatistics=((CultureName="en")))
-+GameTargetsSettings=(Name="MarkdownEditor",Guid=6E9E53F641319F56D59BD1A79AF36E6A,TargetDependencies=(AC8BFD2A41A2FB2893BB8EA0AF903E6D,33482D004789784C9DA695A682ACCA1B),AdditionalManifestDependencies=,RequiredModuleNames=,GatherFromTextFiles=(IsEnabled=True,SearchDirectories=((Path="Plugins/MarkdownEditor/Source")),ExcludePathWildcards=,FileExtensions=((Pattern="h"),(Pattern="cpp"),(Pattern="ini")),ShouldGatherFromEditorOnlyData=False),GatherFromPackages=(IsEnabled=False,IncludePathWildcards=,ExcludePathWildcards=((Pattern="Content/L10N/*")),FileExtensions=((Pattern="umap"),(Pattern="uasset")),Collections=,ExcludeClasses=,ShouldExcludeDerivedClasses=False,ShouldGatherFromEditorOnlyData=False,SkipGatherCache=False),GatherFromMetaData=(IsEnabled=False,IncludePathWildcards=,ExcludePathWildcards=,KeySpecifications=,FieldTypesToInclude=,FieldTypesToExclude=,FieldOwnerTypesToInclude=,FieldOwnerTypesToExclude=,ShouldGatherFromEditorOnlyData=False),ExportSettings=(CollapseMode=IdenticalTextIdAndSource,POFormat=Unreal,ShouldPersistCommentsOnExport=False,ShouldAddSourceLocationsAsComments=True),CompileSettings=(SkipSourceCheck=False,ValidateFormatPatterns=True,ValidateSafeWhitespace=False),ImportDialogueSettings=(RawAudioPath=(Path=""),ImportedDialogueFolder="ImportedDialogue",bImportNativeAsSource=False),NativeCultureIndex=0,SupportedCulturesStatistics=((CultureName="en"),(CultureName="ja")))
++GameTargetsSettings=(Name="MarkdownEditor",Guid=6E9E53F641319F56D59BD1A79AF36E6A,TargetDependencies=(AC8BFD2A41A2FB2893BB8EA0AF903E6D,33482D004789784C9DA695A682ACCA1B),AdditionalManifestDependencies=,RequiredModuleNames=,GatherFromTextFiles=(IsEnabled=True,SearchDirectories=((Path="Plugins/MarkdownAsset/Source/MarkdownAssetEditor")),ExcludePathWildcards=,FileExtensions=((Pattern="h"),(Pattern="cpp"),(Pattern="ini")),ShouldGatherFromEditorOnlyData=False),GatherFromPackages=(IsEnabled=False,IncludePathWildcards=,ExcludePathWildcards=((Pattern="Content/L10N/*")),FileExtensions=((Pattern="umap"),(Pattern="uasset")),Collections=,ExcludeClasses=,ShouldExcludeDerivedClasses=False,ShouldGatherFromEditorOnlyData=False,SkipGatherCache=False),GatherFromMetaData=(IsEnabled=False,IncludePathWildcards=,ExcludePathWildcards=,KeySpecifications=,FieldTypesToInclude=,FieldTypesToExclude=,FieldOwnerTypesToInclude=,FieldOwnerTypesToExclude=,ShouldGatherFromEditorOnlyData=False),ExportSettings=(CollapseMode=IdenticalTextIdAndSource,POFormat=Unreal,ShouldPersistCommentsOnExport=False,ShouldAddSourceLocationsAsComments=True),CompileSettings=(SkipSourceCheck=False,ValidateFormatPatterns=True,ValidateSafeWhitespace=False),ImportDialogueSettings=(RawAudioPath=(Path=""),ImportedDialogueFolder="ImportedDialogue",bImportNativeAsSource=False),NativeCultureIndex=0,SupportedCulturesStatistics=((CultureName="en"),(CultureName="ja")))
 
 [Internationalization]
 +LocalizationPaths=%GAMEDIR%Content/Localization/MarkdownEditor
diff --git a/Config/Localization/MarkdownEditor_Gather.ini b/Config/Localization/MarkdownEditor_Gather.ini
index de26d3b..f83ecf9 100644
--- a/Config/Localization/MarkdownEditor_Gather.ini
+++ b/Config/Localization/MarkdownEditor_Gather.ini
@@ -1,5 +1,4 @@
-; THESE ARE GENERATED FILES, DO NOT EDIT DIRECTLY!
-; USE THE LOCALIZATION DASHBOARD IN THE UNREAL EDITOR TO EDIT THE CONFIGURATION
+;METADATA=(Diff=true, UseCommands=true)
 [CommonSettings]
 ManifestDependencies=../../../../../../Program Files/Epic Games/UE_5.5/Engine/Content/Localization/Editor/Editor.manifest
 ManifestDependencies=../../../../../../Program Files/Epic Games/UE_5.5/Engine/Content/Localization/Engine/Engine.manifest
@@ -13,7 +12,7 @@ CulturesToGenerate=ja
 
 [GatherTextStep0]
 CommandletClass=GatherTextFromSource
-SearchDirectoryPaths=Plugins/MarkdownAsset/Source
+SearchDirectoryPaths=Plugins/MarkdownAsset/Source/MarkdownAssetEditor
 ExcludePathFilters=Config/Localization/*
 FileNameFilters=*.h
 FileNameFilters=*.cpp
diff --git a/Content/Localization/MarkdownEditor/MarkdownEditor.csv b/Content/Localization/MarkdownEditor/MarkdownEditor.csv
index 09c3423..7497a67 100644
--- a/Content/Localization/MarkdownEditor/MarkdownEditor.csv
+++ b/Content/Localization/MarkdownEditor/MarkdownEditor.csv
@@ -1,3 +1,7 @@
 Date/Time,Word Count,en,ja
 2026.03.11-15.05.19,99,99,0
 2026.03.11-15.15.14,99,99,99
+2026.04.19-21.11.13,0,0,0
+2026.04.19-21.14.36,111,111,0
+2026.04.19-21.16.48,111,111,99
+2026.04.19-21.24.03,111,111,111
diff --git a/Content/Localization/MarkdownEditor/MarkdownEditor.manifest b/Content/Localization/MarkdownEditor/MarkdownEditor.manifest
index f345daf06ab8f1bef2045de544867d55aeee8203..88ccdf41021ad1bede1a32f2f000e434476e121e 100644
GIT binary patch
delta 1215
zcma)5T}YE*6h7bPV%qR$4l|S5EX7Q0+ozi&Oqq)2=HF7wSfZmW!BTUQ5yh^?=t??4
zMIc^v5fR$U@+#5D=pw@1MMUhXEAcA2>hFB-=li<RO^lCy@AEw8oaemfd~aSWFW)K4
zLk3(Z&SMe75`V#nA;P9jR{anviW?h1#Z=<~Tr$~NkGWjY<fs#F_9u5(0;UFVLnA7A
z4>4}}E@k!L#8iOCV~;t4u{s;J<eW!aK~QQMz=Z|*PjI2|RTj2em&dKU^|-V(D~@dx
z_h(vA!OJbQl&oc>a%WknE&U)kGOa>AkC;>n(NmTdj8Ua#GL38eK>26ED<1rndkD8q
zRAZkbAFYRn1VfQ3Iy$Ije+}n?N1__XLPZsdqZg*(GF%5cw8K0^>HP+s#$b|=K?p$*
zSIiT~TVaaOahM?X+CR!cLMLH>*eLc^cJso9ri9|fjpE0{dljN^l{B*=GyPBS%C{){
z9ObaXC8|G8)#oT*l+F=Cr{E^VXug^uOnU9P4NkbDIXn43&bldjmVRS!1^X)l!XMf@
zO0_-W^W3(-6&J=g$H#~8wL*@DHqXtPk6o10)mD+Ys!;4^!sw&Xjrkc`YIbBUm7Kab
z>aYE=i)u<Q$6|G#1cuxD$xYKDE;;wGwhA3vcMB{|<8;zElbEjmEvn$XgJl%E%o@G>
zq(75ZTBS0Z_{jHDN^NFcx^v2$E!A9ZvcA(c0SlX(Y^^0<fN@!?s<lvp+*B&C%3|$O
zncy9z+uq;r{3e^EhS<WH7ukW1j#YeKV!;Q&k3y*U=qpd+vmSA0df%x)61VMTxTWOa
zx^Euu_RFsi^~M&l^JqENo&A!LX~vVpu1X7z49Z)Sm&0&0T#Zl9iM!mJBH_$-AxBtE
S=$6=MxGNKy@w8%W#QzsQ1bpED

delta 896
zcmY+BO=uHQ6ooTMltG3ei6JeMl$N4Wi-aU5nKs&DMoev#GF4iml~RjqaV<eaB$TXd
z5BRqzL0pKq81o29L5V+&8wqJwE?lH8T*@HgLW=n2&CD|{?|09;=iK}1E#cj3!I<}A
za!`U6yhhsIlv^z0rcWj}_V{fO8mpo`A3^uPZ9Ee<*o%6yDkSk@|9#xu*JNb-XpJe#
z(obh*#h3J`*va)VZl=O8<R{MS6=95bZUtVs6zQQyNT`<b61GD{ms9nX;fFXKwv{xI
zpfdL(kvEQ}inZtiMEXCm+REH1*qLR;WK0WMi89<*Rzf%)`^<Z3Pa1i>4}qys3=M|x
zd*Gbgqq_=n6wQGg;xUQRt4?Rd$x)h9U`QpD<|K3v7FhR3rbar4W&~EygOU2kWxJs1
z$m7v9_udsDOV^{u+B(Yd@6PB79i5+O&;yIuNO0=Qdd9I;ATU!rx~0?`2xK_%sh%WL
zB~;F+YBg%R=;MD}7c33;Q)h!bJ+{|QNAE<XLD7;L5GQwCDIKcPp_^p!gxD+1Pkbaz
zEzFS<ag)SP$sBT@ds6`psn1UCJ=vZ1_M*K066W*>uAlwZV{Ps8mOP*NPiikzLwQz$
zf40r#S(cPQIseOL%&S3v=&MVdeF(y(7}hU*aXI~t)iVtg4=d;hesnLkc!%AE=nEhI
f<+cA#Uucm#i++yj4Xj%c(pf5U$OfN;xvc#K5aBy6

diff --git a/Content/Localization/MarkdownEditor/en/MarkdownEditor.archive b/Content/Localization/MarkdownEditor/en/MarkdownEditor.archive
index cbe7bdfeccb977488cff85163a6b535e7934b262..7ac498517afdfa33a864e969b9808395f4d99f48 100644
GIT binary patch
delta 388
zcmZ42%DAqFal<b$MSq3@hE#?;1_cIJh6;ufAiD_2OJv9aii9!*G5AbQWGy5@l_7_@
zY92!xLncsvE{0j5K+znA5TI<yWJVj|$pJzskqDbh7&3q|#V{LzbSBtEl??d|r9hnu
z3@Jc&r2$=43N)nz$WH=_<};K7^?=-K&kzGt55m<91`M?z7t_#mpii|4`P3Kau3{ie
cWJsTEFH}0Y#zJaxfnWlJ7FOE4LHwT<020?z#sB~S

delta 30
hcmZ42!?>=Mal<dM$$zY+CKm`MKxkp5%?8r{v;fh?49Wli

diff --git a/Content/Localization/MarkdownEditor/en/MarkdownEditor.locres b/Content/Localization/MarkdownEditor/en/MarkdownEditor.locres
index bf9821cad236b46789c722ebe67aab5899edf6c4..493ca59136a47256204803bac7ab1920205521e9 100644
GIT binary patch
delta 508
zcmca8_)$oTPo$(Y-HZ8;m*|AKht2DyneVYOfPwBrsm+YS8_y*(rka|3Rg?e<I_Kx5
zWftYSR+OX`<t65X7UhIwmgJ-|wDCTD$_JEZdns%!g;kwzYH@L5dMbl!3acMKP{rJ-
zM}DyZ>A=$bl2nGP>!zm&On%EEDIHM%=Z7FrJfSYR8YCZ*m;^L`vHC9`p~)3Y_BO&m
zvHyn+HMxPbQ)y04YKc!~aS6l6sck+YK%omupYjO+Y0tdk)S?pS{FGFuoc!c$hOilz
zw~9{w%#_I}HaV7AnNfUlBeN2t#N;JFQgZTfW_3oX$?uuf7^NqRv8XW0OtxlGV3eI4
z10>}p*8)lT$@5sm7!@X-lTi4zTI`x4(28|V;XlBx09jCo;tg3wrODi^(zZfCWy^al
zpYZ}|r~I6h_>la3V2BkkY-W3XT^S^3SsMom4bPIqoXljnwD8@^9+k<-tg5W4KuNX9
zy{r$sL1y_Eq~<BW0$(9C$cKRuD5?XKDaptz28k+U<|$O>mli3cq^2d7=9DNT73G%$
T!^577tJ<KJfpK#dTRIZ}mqeNN

delta 241
zcmew;bWu=>Po$(Y-HZ8;m*|AKht2DynR{3nz(9MV)MiG(jpvdXCpR+*G4f5eXO)x=
zsQ>eWA1Iwrmt4&Tq(c&ua#9%<tN-#5n0$)Ko>6cz7qb+j&}3C+c}C&MuFRQ?B9qrM
zD>I5tzRaw|C^q>UkQARR$)e6EG1-wtjZt!P28#-#)Z|_k1xD$~>wu)p<nusMcJc=n
zF-EzG=Oh$<troi`5438XQ}_>VAnlZspPXG-nqQL2aCP1E6p*`Q85JhSvPv@wOs-^=
gVN{$vja80OY4TQ9RaRx729?S8Ss!fXWlv!O05bwXYXATM

diff --git a/Content/Localization/MarkdownEditor/ja/MarkdownEditor.archive b/Content/Localization/MarkdownEditor/ja/MarkdownEditor.archive
index 973828303eb2a14cf9f3b1e531d5c851fe9a2501..5680a95b091d5ca39bfd7249f3742924176d2278 100644
GIT binary patch
delta 344
zcmey+$atuOal<7sMSq3@hE#?;1_cIJh6;ufAiD_2OJv9aii9!*G5AcL$W|yE1C$Yq
zd@%tm!Z698d#e9rMi%4A2^=h{c?@X`nLu5+7$$@QMROQJfU+f%4XuPHPvB39MA%ot
zkO7n_hS>w8Gr{htWXNYI1?p5_NCCPg4d|9qpeZFleiBeLpP?M62joh7h8UoF5Uyr0
zV5kMT(=yl~&j9AeN2#--^9-&Tyfj#5u+1PH=w@GoI)g|9Zv*-NF;Kk--Gvfh-{=zZ
hjW5vdVjxUpNM}f$+{j-%*~eUJasg|?W*_k-ngA!7RQmt`

delta 22
ecmX@q!T6z(al<9C$@8qFCKs?KY@R2zL=ymXm<f9T

diff --git a/Content/Localization/MarkdownEditor/ja/MarkdownEditor.locres b/Content/Localization/MarkdownEditor/ja/MarkdownEditor.locres
index 0b9dac67d4001b20886608ade6badc6c7dadefca..67b12e62b2db4789d195c07ef79ee61306bcf13f 100644
GIT binary patch
delta 506
zcmZ3+cZFYyPo$(Y-HZ8;m*|AKht2DynG0ALz(8T5R2n1q#Kv>=rY2t%C4gei`FUxX
zMY*mOC8<Sui8-M~IU$)PIjIb7yicF90p;0V3R_EIRp*;pT%4Gm%HW#9>c<XLF?Z^b
zUmzWUrTHbP3|H4pPvHRa66%txL82jvNkCH<tN-%h1oDh0*DzW~a{*cZ4;yN718Jwy
zoSf7WpUmPChL2O*d_Y1MmOkYZ0Med$#i>Ol&iN^+PC5C>*$iPbE^p-liZA!PEYA<5
zJ@Sh(tMc<o5_5t|fp#q9TAIW=S%^uQk#DjYlM*BU<VYrUMuEwVOlpjRlUFdQFbYjR
z%cQ_4Joz1v6q(G=tiUKb*??KhQVeL=!o>5xc!9KEX>L+#QECd<MZZ>yT@wciu5$|i
z0d_3N9fb&gPOfK`Wt5mamsy&TbMj7R8Ai#;*O=uPr6zx6R%Mk2YLuBQ&$2V}+yDRn
zIT^$vUrY#P2x9PIm}JmB)!%@Dff1<U2~aNBAkP3M^C)#zbe_RAgO>)&47M4h16BGO
f)EPt?cpJ$7k73AT0O4u|1BP0lUdGK=Spt~=2SS-v

delta 277
zcmcb@zl=|cPo$(Y-HZ8;m*|AKht2DyndMj*z(8)IR2n1a#Kv=)bEh8p#Re1$EX^-T
zWw^R-dJ2e_P?uZ{qC*msa#9%<tN-$0pL~kZo{?iR7n2kt=VVnTc?B+@{BqCB^87&B
zBfluKDnG9zF(;@Ls9_=3(j@N5DNM?YJd-<^lo)v@uVzwb<ePk%NsW<z@-HS8MuExl
z%nFQxlO2Gh(BwpB1qorGF`+jkzOn;pPoP1W$qfDMG29}PXEMvkhyn%IIfeh=2GUMB
z`N`RZ2<J||$Slh!Hu*iXG$Z?DZWb9v@yQx2a*Ps_-C0ywC4m~GCKs~o+}y_M#{>X0
CFiAZC


From e0aa375b9e48900040408b22d9f4906d61b01b53 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 12:28:19 +0000
Subject: [PATCH 19/21] Fix literal \n\n appearing in localized external URL
 dialog

LOCTEXT source strings with \n\n{0} required translators to type
escape sequences in the Localization Dashboard, which stores text
verbatim (no C-escape interpretation), causing \n\n to render as
literal characters in the UI.

Move the newline+URL concatenation to C++ code so the localizable
string is a plain question sentence with no format tokens.
---
 .../Private/MarkdownAssetEditorToolkit.cpp                  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
index c621d6d..7a0094e 100644
--- a/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
+++ b/Plugins/MarkdownAsset/Source/MarkdownAssetEditor/Private/MarkdownAssetEditorToolkit.cpp
@@ -766,9 +766,9 @@ bool FMarkdownAssetEditorToolkit::HandleBeforeNavigation(const FString& Url, con
 	// to let the user inspect it before launching (phishing mitigation).
 	if (Url.StartsWith(TEXT("http://")) || Url.StartsWith(TEXT("https://")))
 	{
-		const FText Message = FText::Format(
-			LOCTEXT("ConfirmExternalUrlMessage", "Open this URL in your default browser?\n\n{0}"),
-			FText::FromString(Url)
+		const FText Prompt = LOCTEXT("ConfirmExternalUrlMessage", "Open this URL in your default browser?");
+		const FText Message = FText::FromString(
+			FString::Printf(TEXT("%s\n\n%s"), *Prompt.ToString(), *Url)
 		);
 		const EAppReturnType::Type Response = FMessageDialog::Open(
 			EAppMsgType::YesNo,

From 5d0ba791128d3cee6c92b7fcc1f784f9b5cbdee8 Mon Sep 17 00:00:00 2001
From: EmbarrassingMoment
 <96903403+EmbarrassingMoment@users.noreply.github.com>
Date: Sun, 19 Apr 2026 21:43:37 +0900
Subject: [PATCH 20/21] Update localization

---
 .../MarkdownEditor/ja/MarkdownEditor.archive  | Bin 17474 -> 17456 bytes
 .../MarkdownEditor/ja/MarkdownEditor.locres   | Bin 2004 -> 1990 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/Content/Localization/MarkdownEditor/ja/MarkdownEditor.archive b/Content/Localization/MarkdownEditor/ja/MarkdownEditor.archive
index 5680a95b091d5ca39bfd7249f3742924176d2278..f0605f2074c2d985af7cafb5f48aa3f21c4c0ef2 100644
GIT binary patch
delta 22
ccmX@q!MFj4Y$PWqu&PW}VB*`{AbCg&0A4Hyp#T5?

delta 26
icmdnc!FZ^Haf6K{dkjMiLmorS<e3usn-e52XaN9sO9-q0

diff --git a/Content/Localization/MarkdownEditor/ja/MarkdownEditor.locres b/Content/Localization/MarkdownEditor/ja/MarkdownEditor.locres
index 67b12e62b2db4789d195c07ef79ee61306bcf13f..bcffc802d2152e718c4b6c1a3f5cc2dbf5a9eab8 100644
GIT binary patch
delta 18
Zcmcb@e~f>F8!O}M$?mM$n;Td|m;geZ1~>o!

delta 33
mcmX@ce}#X88!O|J$?mM$d@&4p3?N+1V8Bqzu(^megb4twC<yHU


From a477870e2350fc9509faa15fee915f8f062a1a9c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 19 Apr 2026 12:44:01 +0000
Subject: [PATCH 21/21] Document 1.2.0 security hardening and localization fix
 in changelog

Record the URL-scheme allowlist, preview CSP, external-URL
confirmation dialog, and the MarkdownEditor_Gather.ini path fix
under the 1.2.0 release.
---
 CHANGELOG.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0d89fe4..d38b3ae 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 - **Class Link Scheme** — `[Label](class://ClassName)` resolves the target via UClass lookup; native C++ classes open in the IDE via `FSourceCodeNavigation` (preferring the `.cpp` file, falling back to the header), Blueprint classes open in the Blueprint editor
 - **Broken Link Styling for New Schemes** — `ueasset://` and `class://` targets that cannot be resolved are highlighted in red in the preview, matching existing wikilink behavior
 
+### Security
+
+- **URL Scheme Allowlist** — The preview's `OnBeforeNavigation` handler now default-denies any scheme that is not explicitly supported (`data:`, `about:`, `mdasset://`, `ueasset://`, `class://`, `http(s)://`); unknown schemes such as `javascript:` and `file:` are blocked to prevent script execution or local file access from untrusted Markdown content
+- **Content Security Policy** — Preview HTML now includes a `Content-Security-Policy` meta tag (`default-src 'none'; style-src 'unsafe-inline'; img-src data:`) that blocks all external network requests (remote images, fetch/XHR, frames, fonts), mitigating IP tracking and SSRF against local services from crafted Markdown assets
+- **External URL Confirmation Dialog** — Clicking an `http(s)://` link in the preview now presents a localized confirmation dialog showing the full URL before launching the system browser, mitigating phishing via the address-bar-less preview
+
+### Fixed
+
+- **Localization Gather Path** — Corrected `SearchDirectoryPaths` in `Config/Localization/MarkdownEditor_Gather.ini` which pointed to a non-existent directory (`Plugins/MarkdownEditor/Source`) left over from an earlier plugin rename; now targets `Plugins/MarkdownAsset/Source/MarkdownAssetEditor` so `LOCTEXT` / `NSLOCTEXT` strings are collected correctly by the Localization Dashboard
+
 ## [1.1.0] - 2026-04-04
 
 ### Added