claude-code-arcane 2.3.0 → 2.5.0

package/skills/ue-data-assets-tables/references/asset-loading-patterns.md

@@ -0,0 +1,306 @@
+# Asset Loading Patterns
+
+Reference guide for async loading, `FStreamableManager`, load grouping, and handle lifecycle in Unreal Engine 5.
+
+---
+
+## FStreamableManager Access
+
+`FStreamableManager` is a member of `UAssetManager`. Do not create your own instances in game code — share the one owned by the Asset Manager.
+
+```cpp
+// Preferred access (UE5):
+FStreamableManager& SM = UAssetManager::GetStreamableManager();
+// Equivalent to: UAssetManager::Get().StreamableManager
+```
+
+Module dependency required in `Build.cs`:
+```csharp
+PublicDependencyModuleNames.AddRange(new string[] { "Engine", "AssetManager" });
+```
+
+---
+
+## Pattern 1: Single Asset, Callback on Completion
+
+```cpp
+// Header
+TSharedPtr<FStreamableHandle> LoadHandle;
+
+UPROPERTY(EditDefaultsOnly)
+TSoftObjectPtr<UStaticMesh> WeaponMeshSoft;
+
+// Load
+void AMyCharacter::BeginLoadWeaponMesh()
+{
+    FStreamableManager& SM = UAssetManager::GetStreamableManager();
+
+    LoadHandle = SM.RequestAsyncLoad(
+        WeaponMeshSoft.ToSoftObjectPath(),
+        FStreamableDelegate::CreateUObject(this, &AMyCharacter::OnWeaponMeshReady));
+}
+
+void AMyCharacter::OnWeaponMeshReady()
+{
+    // At callback time, IsValid() returns true if successfully loaded.
+    if (WeaponMeshSoft.IsValid())
+    {
+        WeaponMeshComp->SetStaticMesh(WeaponMeshSoft.Get());
+    }
+    // Handle can now be released; assets stay in memory while referenced by component.
+    LoadHandle.Reset();
+}
+```
+
+---
+
+## Pattern 2: Multiple Assets, Single Callback
+
+Load a batch and receive one callback when all are ready.
+
+```cpp
+void UMyLoadSystem::LoadUIAssets(const TArray<TSoftObjectPtr<UTexture2D>>& IconRefs)
+{
+    TArray<FSoftObjectPath> Paths;
+    Paths.Reserve(IconRefs.Num());
+    for (const TSoftObjectPtr<UTexture2D>& Ref : IconRefs)
+    {
+        if (!Ref.IsNull())
+        {
+            Paths.Add(Ref.ToSoftObjectPath());
+        }
+    }
+
+    if (Paths.IsEmpty()) { return; }
+
+    FStreamableManager& SM = UAssetManager::GetStreamableManager();
+    UILoadHandle = SM.RequestAsyncLoad(
+        Paths,
+        FStreamableDelegate::CreateUObject(this, &UMyLoadSystem::OnUIAssetsLoaded));
+}
+
+void UMyLoadSystem::OnUIAssetsLoaded()
+{
+    // Retrieve loaded assets from handle.
+    TArray<UTexture2D*> LoadedIcons;
+    UILoadHandle->GetLoadedAssets(LoadedIcons);
+
+    for (UTexture2D* Icon : LoadedIcons)
+    {
+        if (Icon) { /* bind to widget */ }
+    }
+}
+```
+
+---
+
+## Pattern 3: High Priority / Synchronous Fallback
+
+For assets needed immediately (e.g., during level transition):
+
+```cpp
+// Option A: RequestSyncLoad — blocks until done.
+// Use only for small assets or during loading screens.
+TSharedPtr<FStreamableHandle> Handle = SM.RequestSyncLoad(
+    AssetPath,
+    false,                                              // bManageActiveHandle
+    TEXT("LevelTransition sync load"));
+
+UObject* Asset = Handle->GetLoadedAsset();
+
+// Option B: WaitUntilComplete on an already-started async load.
+if (LoadHandle.IsValid() && LoadHandle->IsLoadingInProgress())
+{
+    LoadHandle->WaitUntilComplete(5.f); // Timeout seconds; 0 = wait forever.
+}
+```
+
+---
+
+## Pattern 4: Lambda Callback with Captured State
+
+```cpp
+FPrimaryAssetId AssetId(TEXT("WeaponDefinition"), TEXT("DA_Rifle"));
+
+TSharedPtr<FStreamableHandle> Handle = UAssetManager::Get().LoadPrimaryAsset(
+    AssetId,
+    TArray<FName>{ TEXT("Game") },
+    FStreamableDelegate::CreateLambda([this, AssetId]()
+    {
+        UWeaponDefinition* Def =
+            UAssetManager::Get().GetPrimaryAssetObject<UWeaponDefinition>(AssetId);
+        if (Def && IsValid(this))
+        {
+            EquipWeapon(Def);
+        }
+    }));
+```
+
+Important: Lambdas capturing `this` are not safe if the object is destroyed before the callback fires. Use `CreateUObject` (which checks object validity) or guard with `IsValid(this)`.
+
+---
+
+## Pattern 5: Progress Tracking
+
+```cpp
+void UMyLoadingScreen::StartLoadWithProgress(const TArray<FSoftObjectPath>& Assets)
+{
+    FStreamableManager& SM = UAssetManager::GetStreamableManager();
+
+    LoadHandle = SM.RequestAsyncLoad(
+        Assets,
+        FStreamableDelegate::CreateUObject(this, &UMyLoadingScreen::OnLoadComplete));
+}
+
+// Poll from Tick or a timer.
+void UMyLoadingScreen::Tick(float DeltaTime)
+{
+    if (LoadHandle.IsValid() && LoadHandle->IsLoadingInProgress())
+    {
+        float Progress = LoadHandle->GetLoadProgress(); // 0.0 to 1.0
+        ProgressBar->SetPercent(Progress);
+    }
+}
+
+void UMyLoadingScreen::OnLoadComplete()
+{
+    ProgressBar->SetPercent(1.f);
+    LoadHandle.Reset();
+    HideLoadingScreen();
+}
+```
+
+---
+
+## Pattern 6: Load Grouping with Asset Manager Bundles
+
+Bundle state transitions are the recommended way to manage groups of related assets across gameplay states.
+
+```cpp
+UAssetManager& AM = UAssetManager::Get();
+
+// Get all weapon IDs.
+TArray<FPrimaryAssetId> WeaponIds;
+AM.GetPrimaryAssetIdList(FPrimaryAssetType(TEXT("WeaponDefinition")), WeaponIds);
+
+// On entering the main menu: load UI bundle only.
+AM.LoadPrimaryAssets(WeaponIds, { TEXT("UI") });
+
+// On entering gameplay: add Game bundle, keep UI or remove it.
+AM.ChangeBundleStateForPrimaryAssets(
+    WeaponIds,
+    { TEXT("Game") },   // AddBundles
+    { TEXT("UI") },     // RemoveBundles
+    false,              // bRemoveAllBundles
+    FStreamableDelegate::CreateLambda([]() { /* gameplay ready */ }));
+
+// On leaving gameplay: unload Game bundle, keep UI.
+AM.ChangeBundleStateForMatchingPrimaryAssets(
+    { TEXT("UI") },     // NewBundles
+    { TEXT("Game") });  // OldBundles (removes these)
+```
+
+---
+
+## Handle Lifecycle Rules
+
+| State | Meaning |
+|---|---|
+| `IsLoadingInProgress()` | Async load still running |
+| `HasLoadCompleted()` | All assets loaded (callback may not have fired yet if deferred) |
+| `WasCanceled()` | `CancelHandle()` was called; completion callback not invoked |
+| `HasError()` | One or more assets failed to load |
+
+**Ownership rules:**
+- `TSharedPtr<FStreamableHandle>` keeps assets pinned while alive.
+- Letting the `TSharedPtr` go out of scope calls `ReleaseHandle()` implicitly.
+- `ReleaseHandle()` is deferred if called before the completion callback fires; callback still runs.
+- `CancelHandle()` cancels immediately — completion callback is NOT called; cancel callback is called if bound.
+
+```cpp
+// Cancellation with a cancel callback.
+Handle->BindCancelDelegate(FStreamableDelegate::CreateLambda([]()
+{
+    UE_LOG(LogTemp, Warning, TEXT("Load was canceled."));
+}));
+Handle->CancelHandle();
+```
+
+---
+
+## Combined / Merged Handles
+
+When multiple independent loads should be tracked as one unit:
+
+```cpp
+TSharedPtr<FStreamableHandle> HandleA = SM.RequestAsyncLoad(PathA, {});
+TSharedPtr<FStreamableHandle> HandleB = SM.RequestAsyncLoad(PathB, {});
+
+// Combine into a single tracking handle. CreateCombinedHandle is on FStreamableManager.
+TSharedPtr<FStreamableHandle> Merged = SM.CreateCombinedHandle({ HandleA, HandleB });
+
+Merged->BindCompleteDelegate(FStreamableDelegate::CreateLambda([]()
+{
+    // Both A and B are loaded.
+}));
+```
+
+---
+
+## Priority Constants
+
+From `Engine/StreamableManager.h` (namespace `UE::StreamableManager::Private`):
+
+```cpp
+constexpr TAsyncLoadPriority DefaultAsyncLoadPriority = 0;
+constexpr TAsyncLoadPriority AsyncLoadHighPriority     = 100;
+```
+
+Pass priority to `RequestAsyncLoad`:
+```cpp
+SM.RequestAsyncLoad(
+    Paths, Delegate,
+    UE::StreamableManager::Private::AsyncLoadHighPriority);
+```
+
+---
+
+## Anti-Patterns
+
+### Releasing Handle Before Using Loaded Assets
+
+```cpp
+// BAD: assets may be GC'd immediately after Reset().
+SM.RequestAsyncLoad(Path, [this]() {
+    LoadHandle.Reset(); // released inside callback
+    UStaticMesh* Mesh = MeshSoft.Get(); // nullptr — already GC'd
+});
+
+// GOOD: only reset after assigning to a hard reference.
+SM.RequestAsyncLoad(Path, [this]() {
+    MeshComp->SetStaticMesh(MeshSoft.Get()); // component holds the ref
+    LoadHandle.Reset();                      // safe to release now
+});
+```
+
+### Calling LoadSynchronous in Tick
+
+```cpp
+// BAD: stalls every frame if asset not cached.
+void AMyActor::Tick(float DeltaTime)
+{
+    UStaticMesh* Mesh = MeshSoft.LoadSynchronous(); // blocks rendering
+}
+
+// GOOD: start async load once, use result only after callback.
+```
+
+### Ignoring Load Errors
+
+```cpp
+// Always check after callback:
+if (Handle->HasError())
+{
+    UE_LOG(LogTemp, Error, TEXT("One or more assets failed to load."));
+}
+```

package/skills/ue-data-assets-tables/references/data-driven-design.md

@@ -0,0 +1,378 @@
+# Data-Driven Design in Unreal Engine
+
+Patterns for structuring game data using `UDataAsset`, `UPrimaryDataAsset`, and `UDataTable` so designers control gameplay values without C++ changes.
+
+---
+
+## Core Principle
+
+Data-driven design separates **what** (values, configurations, relationships) from **how** (C++ logic). C++ defines the schema; designers populate instances in the editor or spreadsheets.
+
+| Layer | Owner | Tool |
+|---|---|---|
+| Data schema | Programmer | C++ `USTRUCT` / `UCLASS` |
+| Data values | Designer | Data Asset editor, CSV/JSON |
+| Data loading | Programmer | Asset Manager, soft refs |
+| Data consumption | Programmer | `FindRow`, `GetPrimaryAssetObject` |
+
+---
+
+## Pattern A: Item / Ability Definitions (UPrimaryDataAsset)
+
+Best when each item has unique properties, may need Blueprint extension, and should integrate with the Asset Manager for selective loading.
+
+### Schema
+
+```cpp
+// ItemDefinition.h
+#pragma once
+#include "Engine/DataAsset.h"
+#include "GameplayTagContainer.h"
+#include "ItemDefinition.generated.h"
+
+UENUM(BlueprintType)
+enum class EItemRarity : uint8
+{
+    Common,
+    Uncommon,
+    Rare,
+    Legendary
+};
+
+UCLASS(BlueprintType)
+class MYGAME_API UItemDefinition : public UPrimaryDataAsset
+{
+    GENERATED_BODY()
+public:
+    // Identity
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Item")
+    FText DisplayName;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Item")
+    FText Description;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Item")
+    EItemRarity Rarity = EItemRarity::Common;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Item",
+              AssetRegistrySearchable)
+    FGameplayTagContainer ItemTags;
+
+    // Stats
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Stats")
+    float BaseDamage = 0.f;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Stats")
+    int32 MaxStack = 1;
+
+    // UI bundle: loaded in inventory screen.
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Art",
+              meta = (AssetBundles = "UI"))
+    TSoftObjectPtr<UTexture2D> Icon;
+
+    // Game bundle: loaded in the world.
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Art",
+              meta = (AssetBundles = "Game"))
+    TSoftObjectPtr<UStaticMesh> WorldMesh;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Spawning",
+              meta = (AssetBundles = "Game"))
+    TSoftClassPtr<AActor> DroppedActorClass;
+};
+```
+
+### DefaultGame.ini Registration
+
+```ini
+[/Script/Engine.AssetManagerSettings]
++PrimaryAssetTypesToScan=(
+    PrimaryAssetType="ItemDefinition",
+    AssetBaseClass=/Script/MyGame.ItemDefinition,
+    bHasBlueprintClasses=False,
+    bIsEditorOnly=False,
+    Directories=((Path="/Game/Data/Items")),
+    Rules=(Priority=1,ChunkId=-1,bApplyRecursively=True,CookRule=AlwaysCook))
+```
+
+### Discovery and Loading
+
+```cpp
+// Get all item IDs (no assets loaded yet).
+TArray<FPrimaryAssetId> AllItemIds;
+UAssetManager::Get().GetPrimaryAssetIdList(
+    FPrimaryAssetType(TEXT("ItemDefinition")), AllItemIds);
+
+// Filter by tag using Asset Registry (no load).
+IAssetRegistry& AR = IAssetRegistry::GetChecked();
+TArray<FAssetData> MeleeAssets;
+AR.GetAssetsByClass(
+    FTopLevelAssetPath(TEXT("/Script/MyGame"), TEXT("ItemDefinition")),
+    MeleeAssets, true);
+
+// Load UI bundle for inventory.
+UAssetManager::Get().LoadPrimaryAssetsWithType(
+    FPrimaryAssetType(TEXT("ItemDefinition")),
+    { TEXT("UI") });
+
+// After callback: retrieve a specific item.
+FPrimaryAssetId SwordId(TEXT("ItemDefinition"), TEXT("DA_Sword"));
+UItemDefinition* Sword =
+    UAssetManager::Get().GetPrimaryAssetObject<UItemDefinition>(SwordId);
+```
+
+---
+
+## Pattern B: Stat Tables (UDataTable)
+
+Best for large, flat, designer-authored datasets where all rows share the same shape: XP curves, damage falloff, NPC dialogue, loot drop weights.
+
+### Row Struct
+
+```cpp
+// XPTableRow.h
+#pragma once
+#include "Engine/DataTable.h"
+#include "XPTableRow.generated.h"
+
+USTRUCT(BlueprintType)
+struct FXPTableRow : public FTableRowBase
+{
+    GENERATED_BODY()
+
+    /** Player level. Also used as the row name in the DataTable. */
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    int32 Level = 1;
+
+    /** XP required to reach this level from the previous one. */
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    int32 XPRequired = 0;
+
+    /** Stat multiplier applied at this level. */
+    UPROPERTY(EditAnywhere, BlueprintReadWrite)
+    float StatMultiplier = 1.f;
+
+    // Validate row after import.
+    virtual void OnPostDataImport(const UDataTable* InDataTable,
+                                  const FName InRowName,
+                                  TArray<FString>& OutCollectedImportProblems) override
+    {
+        if (XPRequired < 0)
+        {
+            OutCollectedImportProblems.Add(
+                FString::Printf(TEXT("Row '%s': XPRequired cannot be negative."),
+                                *InRowName.ToString()));
+        }
+    }
+};
+```
+
+### CSV Format
+
+```csv
+---,Level,XPRequired,StatMultiplier
+Level_1,1,0,1.0
+Level_2,2,100,1.05
+Level_3,3,250,1.10
+Level_4,4,500,1.15
+```
+
+The first column (`---` or `Name`) is the row name. Import via: DataTable asset > Import > select CSV.
+
+### Runtime Lookup
+
+```cpp
+// Stored as a hard reference because it is small and always needed.
+UPROPERTY(EditDefaultsOnly, Category = "Data")
+TObjectPtr<UDataTable> XPTable;
+
+FXPTableRow* ULevelingComponent::GetRowForLevel(int32 Level) const
+{
+    if (!XPTable) { return nullptr; }
+    FName RowName = FName(*FString::Printf(TEXT("Level_%d"), Level));
+    return XPTable->FindRow<FXPTableRow>(RowName, TEXT("GetRowForLevel"));
+}
+
+int32 ULevelingComponent::GetXPToNextLevel(int32 CurrentLevel) const
+{
+    const FXPTableRow* Row = GetRowForLevel(CurrentLevel + 1);
+    return Row ? Row->XPRequired : 0;
+}
+```
+
+---
+
+## Pattern C: Config Objects (UDataAsset — Not Primary)
+
+Use plain `UDataAsset` (not Primary) for global configuration that is always loaded with the referencing class, is not addressable by ID, and does not need Asset Manager integration.
+
+```cpp
+// GameBalanceConfig.h
+#pragma once
+#include "Engine/DataAsset.h"
+#include "GameBalanceConfig.generated.h"
+
+UCLASS(BlueprintType)
+class MYGAME_API UGameBalanceConfig : public UDataAsset
+{
+    GENERATED_BODY()
+public:
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Economy")
+    int32 StartingGold = 100;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Economy")
+    float SellPriceMultiplier = 0.5f;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Combat")
+    float GlobalDamageScale = 1.f;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Combat")
+    float CritMultiplier = 2.f;
+};
+```
+
+Reference from GameMode or GameInstance with a hard `TObjectPtr`:
+
+```cpp
+UPROPERTY(EditDefaultsOnly, Category = "Config")
+TObjectPtr<UGameBalanceConfig> BalanceConfig;
+```
+
+---
+
+## Pattern D: Hybrid — DataAsset with DataTable Reference
+
+An item definition holds a soft reference to a DataTable for per-tier stat scaling, while the DataAsset handles identity and art.
+
+```cpp
+UCLASS(BlueprintType)
+class MYGAME_API UWeaponDefinition : public UPrimaryDataAsset
+{
+    GENERATED_BODY()
+public:
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")
+    FText WeaponName;
+
+    // Reference to a scaling table — loaded on demand.
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Stats",
+              meta = (AssetBundles = "Game"))
+    TSoftObjectPtr<UDataTable> ScalingTable;
+
+    float GetDamageAtTier(int32 Tier) const
+    {
+        // ScalingTable must already be loaded (via bundle).
+        UDataTable* Table = ScalingTable.Get();
+        if (!Table) { return 0.f; }
+
+        FName RowName = FName(*FString::Printf(TEXT("Tier_%d"), Tier));
+        const FWeaponScalingRow* Row =
+            Table->FindRow<FWeaponScalingRow>(RowName, TEXT("GetDamageAtTier"));
+        return Row ? Row->Damage : 0.f;
+    }
+};
+```
+
+---
+
+## Pattern E: Subsystem as Data Gateway
+
+A `UGameInstanceSubsystem` caches loaded data assets after initial scan, providing a central access point that avoids repeated Asset Manager calls throughout the codebase.
+
+```cpp
+// ItemSubsystem.h
+#pragma once
+#include "Subsystems/GameInstanceSubsystem.h"
+#include "ItemSubsystem.generated.h"
+
+UCLASS()
+class MYGAME_API UItemSubsystem : public UGameInstanceSubsystem
+{
+    GENERATED_BODY()
+public:
+    virtual void Initialize(FSubsystemCollectionBase& Collection) override;
+
+    UItemDefinition* GetItemById(const FPrimaryAssetId& Id) const;
+    TArray<UItemDefinition*> GetItemsByTag(FGameplayTag Tag) const;
+
+private:
+    void OnItemsLoaded();
+
+    TMap<FPrimaryAssetId, TObjectPtr<UItemDefinition>> ItemCache;
+    TSharedPtr<FStreamableHandle> LoadHandle;
+};
+```
+
+```cpp
+// ItemSubsystem.cpp
+void UItemSubsystem::Initialize(FSubsystemCollectionBase& Collection)
+{
+    Super::Initialize(Collection);
+
+    UAssetManager& AM = UAssetManager::Get();
+    TArray<FPrimaryAssetId> ItemIds;
+    AM.GetPrimaryAssetIdList(FPrimaryAssetType(TEXT("ItemDefinition")), ItemIds);
+
+    LoadHandle = AM.LoadPrimaryAssets(
+        ItemIds,
+        { TEXT("UI") },
+        FStreamableDelegate::CreateUObject(this, &UItemSubsystem::OnItemsLoaded));
+}
+
+void UItemSubsystem::OnItemsLoaded()
+{
+    UAssetManager& AM = UAssetManager::Get();
+    TArray<UObject*> LoadedObjects;
+    AM.GetPrimaryAssetObjectList(FPrimaryAssetType(TEXT("ItemDefinition")), LoadedObjects);
+
+    for (UObject* Obj : LoadedObjects)
+    {
+        if (UItemDefinition* Item = Cast<UItemDefinition>(Obj))
+        {
+            ItemCache.Add(Item->GetPrimaryAssetId(), Item);
+        }
+    }
+}
+
+UItemDefinition* UItemSubsystem::GetItemById(const FPrimaryAssetId& Id) const
+{
+    const TObjectPtr<UItemDefinition>* Found = ItemCache.Find(Id);
+    return Found ? Found->Get() : nullptr;
+}
+
+TArray<UItemDefinition*> UItemSubsystem::GetItemsByTag(FGameplayTag Tag) const
+{
+    TArray<UItemDefinition*> Results;
+    for (const auto& Pair : ItemCache)
+    {
+        if (Pair.Value && Pair.Value->ItemTags.HasTag(Tag))
+        {
+            Results.Add(Pair.Value);
+        }
+    }
+    return Results;
+}
+```
+
+---
+
+## When to Use Each Approach
+
+| Scenario | Recommended Approach |
+|---|---|
+| Per-item configs, ~10–500 items, designers use editor | `UPrimaryDataAsset` + Asset Manager |
+| Large flat tables, designers use Excel/Sheets | `UDataTable` + CSV import |
+| Global game settings, always in memory | `UDataAsset` (plain), hard reference |
+| Server-only data (drop rates, economy) | `UDataTable` with `bStripFromClientBuilds=true` |
+| Items with stat scaling per tier | Hybrid: PrimaryDataAsset + soft ref to DataTable |
+| Runtime-generated content | `UDataTable::AddRow`, or dynamic `FPrimaryAssetId` via `AddDynamicAsset` |
+| Querying without loading | `IAssetRegistry::GetAssetsByClass` + `FAssetData` |
+
+---
+
+## Designer Workflow Checklist
+
+1. **C++ schema merged**: Row struct or DataAsset class is compiled and visible in the editor.
+2. **Asset registered**: `DefaultGame.ini` has the correct `PrimaryAssetTypesToScan` entry (for PrimaryDataAssets).
+3. **Editor asset created**: Data Asset instances or DataTable created in Content Browser under the scanned path.
+4. **Data populated**: Fields filled in the editor or CSV imported.
+5. **Cook verified**: Launch a development cook and confirm assets appear in the cooked output. Check for "Asset not in cook" warnings in the log.
+6. **Bundle states tested**: Verify UI bundle loads in menus and Game bundle loads during gameplay without performance spikes.