Possible bug with program block that saves into Storage when it shouldn't

I've been working on an assembler script for automating component production process.

The first script works as an "installer", saving to storage list of found components/tools/weapons in a specific cargo container. The other script need to read that data to know with which products it's going to work. I've also set both scripts to write to the CustomData to make it easier to see what is being saved to Storage.

However I found a wierd behavior which I belive is a bug: the second script, to which I call "controller", only ever save if either being asked to via argument "save" or when saving the game. In both cases Save() function should be called.

However, as far as I know, Save() should not be called if either the block is off or if recompiling. and yet it does that, evidant by CustomData of the block being filled with the item list even after menual deletion.

Playing latest version of the game with no mods, creative mode.

Code for installer script:

string targetContainerName = "Component Storage";

public void Main(string argument)
{
    if (argument == "show")
    {
        ShowStoredData();
        return;
    }

    IMyCargoContainer targetContainer = GridTerminalSystem.GetBlockWithName(targetContainerName) as IMyCargoContainer;

    if (targetContainer == null)
    {
        Echo($"Error: No cargo container named '{targetContainerName}' found.");
        return;
    }

    IMyInventory inventory = targetContainer.GetInventory(0);
    List<MyInventoryItem> items = new List<MyInventoryItem>();
    inventory.GetItems(items);

    HashSet<string> storedItems = new HashSet<string>();
    StringBuilder storageData = new StringBuilder();

    Storage = "";

    storageData.Append("[ITEMS]\n"); // Block header

    int itemCounter = 0;

    foreach (MyInventoryItem item in items)
    {
        string subtypeId = item.Type.SubtypeId;
        string typeId = item.Type.TypeId;
        string displayName = FormatDisplayName(subtypeId); // Auto-format name

        if (IsAssemblerCraftable(typeId, subtypeId) && !storedItems.Contains(subtypeId))
        {
            storedItems.Add(subtypeId);

            int defaultStock = (IsCharacterToolOrWeapon(typeId)) ? 0 : 1000;
            string itemFilterType = ItemType(typeId);

            if (!string.IsNullOrEmpty(itemFilterType))
            {
                itemCounter++;
                storageData.Append($"{displayName}:{subtypeId}:{itemFilterType}:{defaultStock}\n");
            }
        }
    }

    storageData.Append("[ITEM_COUNT]\n");
    storageData.Append($"{itemCounter}\n");
    storageData.Append("[END]\n"); // Marks end of ITEMS block

    /* Preserve other blocks in Storage
    string[] existingData = Storage.Split('\n');
    StringBuilder newStorage = new StringBuilder();
    bool insideItemsBlock = false;

    foreach (string line in existingData)
    {
        if (line.Trim() == "[ITEMS]")
        {
            insideItemsBlock = true; // Skip old item block
            continue;
        }
        else if (line.StartsWith("[") && insideItemsBlock)
        {
            insideItemsBlock = false; // Found another block, stop skipping
        }

        if (!insideItemsBlock)
        {
            newStorage.AppendLine(line); // Preserve non-item blocks
        }
    }

    // Append the updated `[ITEMS]` block
    newStorage.AppendLine(storageData.ToString());*/

    //Storage = newStorage.ToString();
    Storage = storageData.ToString();
    Me.CustomData = storageData.ToString(); // Also save to Custom Data

    // Output results
    Echo($"Scanning 'Component Storage'...");
    Echo($"Total unique assembler items found: {storedItems.Count}");
}

// Function to display stored data when running with "show" argument
void ShowStoredData()
{
    Echo("Stored Items List:");
    string[] storedLines = Storage.Split('\n');

    if (storedLines.Length == 0 || string.IsNullOrWhiteSpace(Storage))
    {
        Echo("No stored data found.");
        return;
    }

    foreach (string line in storedLines)
    {
        Echo(line);
    }
}

// Check if an item is assembler-craftable
bool IsAssemblerCraftable(string typeId, string subtypeId)
{
    return typeId.Contains("Component") ||    // Components
           typeId.Contains("PhysicalGunObject") || // Weapons
           typeId.Contains("OxygenContainerObject") || // O2 Bottles
           typeId.Contains("GasContainerObject") || // H2 Bottles
           typeId.Contains("HandTool") || // Grinders, Welders, Drills
           typeId.Contains("AmmoMagazine") || // Ammo, Flare Clips, Fireworks
           typeId.Contains("Datapad"); // Datapads
}

bool IsCharacterToolOrWeapon(string typeID)
{
    return typeID.Contains("PhysicalGunObject") || typeID.Contains("HandTool");
}

string ItemType(string typeId)
{
    // Get just the last part of the TypeId (e.g., from "MyObjectBuilder_Component" → "Component")
    if (typeId.Contains("_"))
        typeId = typeId.Substring(typeId.LastIndexOf("_") + 1);

    if (typeId == "Component") return "Component";
    if (typeId == "PhysicalGunObject") return "Weapon";
    if (typeId == "OxygenContainerObject") return "O2 Bottle";
    if (typeId == "GasContainerObject") return "H2 Bottle";
    if (typeId == "HandTool") return "Tool";
    if (typeId == "AmmoMagazine") return "Ammo";
    if (typeId == "Datapad") return "Datapad";

    return "";
}

// Dynamically generates proper display names
string FormatDisplayName(string subtypeId)
{
    string formattedName;

    // Special cases for components
    if (subtypeId == "Construction") return "Construction Comp.";
    if (subtypeId == "SmallTube") return "Small Steel Tube";
    if (subtypeId == "LargeTube") return "Large Steel Tube";
    if (subtypeId == "Medical") return "Medical Comp.";

    // Special cases for fireworks
    if (subtypeId == "FireworksBoxGreen") return "Fireworks Green";
    if (subtypeId == "FireworksBoxRed") return "Fireworks Red";
    if (subtypeId == "FireworksBoxBlue") return "Fireworks Blue";
    if (subtypeId == "FireworksBoxYellow") return "Fireworks Yellow";
    if (subtypeId == "FireworksBoxPink") return "Fireworks Pink";
    if (subtypeId == "FireworksBoxRainbow") return "Fireworks Rainbow";
    if (subtypeId == "FlareClip") return "Flare Gun Clip";

    // Special cases for ammo
    if (subtypeId == "Missile200mm") return "Rocket";
    if (subtypeId == "AutocannonClip") return "Autocannon Magazine";
    if (subtypeId == "NATO_25x184mm") return "Gatling Ammo Box";
    if (subtypeId == "LargeCalibreAmmo") return "Artillery Shell";
    if (subtypeId == "LargeRailgunAmmo") return "Large Railgun Sabot";
    if (subtypeId == "SmallRailgunAmmo") return "Small Railgun Sabot";
    if (subtypeId == "MediumCalibreAmmo") return "Assault Cannon Shell";
    if (subtypeId == "FullAutoPistolMagazine") return "S-20A Pistol Magazine";
    if (subtypeId == "SemiAutoPistolMagazine") return "S-10 Pistol Magazine";
    if (subtypeId == "ElitePistolMagazine") return "S-10E Pistol Magazine";
    if (subtypeId == "AutomaticRifleGun_Mag_20rd") return "MR-20 Rifle Magazine";
    if (subtypeId == "RapidFireAutomaticRifleGun_Mag_50rd") return "MR-50A Rifle Magazine";
    if (subtypeId == "PreciseAutomaticRifleGun_Mag_5rd") return "MR-8P Rifle Magazine";
    if (subtypeId == "UltimateAutomaticRifleGun_Mag_30rd") return "MR-30E Rifle Magazine";

    // Special cases for weapons
    if (subtypeId == "SemiAutoPistolItem") return "S-10 Pistol";
    if (subtypeId == "FullAutoPistolItem") return "S-20A Pistol";
    if (subtypeId == "ElitePistolItem") return "S-10E Pistol";
    if (subtypeId == "AutomaticRifleItem") return "MR-20 Rifle";
    if (subtypeId == "RapidFireAutomaticRifleItem") return "MR-50A Rifle";
    if (subtypeId == "UltimateAutomaticRifleItem") return "MR-30E Rifle";
    if (subtypeId == "PreciseAutomaticRifleItem") return "MR-8P Rifle";
    if (subtypeId == "BasicHandHeldLauncherItem") return "RO-1 Rocket Launcher";
    if (subtypeId == "AdvancedHandHeldLauncherItem") return "PRO-1 Rocket Launcher";

    // Special cases for tools
    if (subtypeId.EndsWith("Item"))
    {
        string baseName = subtypeId.Replace("Item", ""); // Remove "Item"
        string tier = "";

        if (baseName.EndsWith("2")) { tier = "Enhanced"; baseName = baseName.Remove(baseName.Length - 1); }
        else if (baseName.EndsWith("3")) { tier = "Proficient"; baseName = baseName.Remove(baseName.Length - 1); }
        else if (baseName.EndsWith("4")) { tier = "Elite"; baseName = baseName.Remove(baseName.Length - 1); }

        // Convert to proper display name
        formattedName = System.Text.RegularExpressions.Regex.Replace(baseName, "(\\B[A-Z])", " $1");

        return tier == "" ? formattedName : $"{tier} {formattedName}";
    }

    // Automatically add spaces between words based on uppercase letters
    formattedName = System.Text.RegularExpressions.Regex.Replace(subtypeId, "(\\B[A-Z])", " $1");

    return formattedName;
}

bool debugMode = true;

string outContainerName;

IMyCargoContainer outputContainer;
List<IMyAssembler> assemblers;

Dictionary<string, ItemData> itemDictionary;

class ItemData
{
    public string DisplayName;
    public string SubTypeID;
    public string ItemType;
    public int StockLevel;

    public ItemData(string displayName, string subTypeID, string itemType, int stockLevel)
    {
        DisplayName = displayName;
        SubTypeID = subTypeID;
        ItemType = itemType;
        StockLevel = stockLevel;
    }
}

public Program()
{
    //Runtime.UpdateFrequency = UpdateFrequency.Update10;

    itemDictionary = new Dictionary<string, ItemData>();

    Load();
}

void Save()
{
    DebugMsg("calling save process");
            
    StringBuilder output = new StringBuilder();
    output.Append("[ITEMS]\n");

    int count = 0;
    foreach (var pair in itemDictionary)
    {
        count++;
        var data = pair.Value;
        output.Append($"{data.DisplayName}:{data.SubTypeID}:{data.ItemType}:{data.StockLevel}\n");
    }

    output.Append("[ITEM_COUNT]\n");
    output.Append($"{count}\n");
    output.Append("[END]\n");

    Storage = output.ToString();
    Me.CustomData = output.ToString(); // Optional: makes it easier to see
}

public void Load()
{
    DebugMsg("loading");
            
    itemDictionary.Clear();
    string[] lines = Storage.Split('\n');

    bool insideItemBlock = false;
    bool expectingItemCount = false;

    int totalItems = 0;

    foreach (string line in lines)
    {
        string trimmedLine=line.Trim();

        if (trimmedLine == "[ITEM_COUNT]") 
        {
            expectingItemCount = true;
            continue;
        }
        else if(expectingItemCount)
        {
            totalItems = int.Parse(trimmedLine);
            expectingItemCount = false;
        }
    }

    if (totalItems == 0) 
    {
        DebugMsg("Failed to load, no items found.");
        return;
    }

    int itemCounter = 1;

    DebugMsg($"Total lines: {lines.Length}");
    foreach (string line in lines)
    {
        DebugMsg($"LINE RAW: '{line}'");
    }

    foreach (string line in lines)
    {
        string trimmedLine = line.Trim();

        if (trimmedLine == "[ITEMS]")
        {
            insideItemBlock = true;
            continue;
        }
        else if (trimmedLine == "[END]") 
        {
            insideItemBlock = false;
            break;
        }

        DebugMsg($"reading item block: {insideItemBlock}");

        if (insideItemBlock && trimmedLine.Contains(":") && itemCounter <= totalItems)
        {
            string[] parts = trimmedLine.Split(new char[] { ':' }, 4);
            DebugMsg("trying to process...");
            if (parts.Length == 4)
            {
                DebugMsg("Processing...");
                string displayName = parts[0].Trim();
                string subtypeID = parts[1].Trim();
                string itemType = parts[2].Trim();
                int stockLevel = int.Parse(parts[3].Trim());

                string itemKey = $"Item{itemCounter}";
                itemDictionary[itemKey] = new ItemData(displayName, subtypeID, itemType, stockLevel);

                DebugMsg($"Parsed {itemKey} = {displayName}, {subtypeID}, {itemType}, {stockLevel}");

                itemCounter++;
            }
            else
            {
                DebugMsg("Processing error");
                return;
            }
        }
    }
    DebugMsg("Load completed");
}

public void Main(string argument)
{
    if (argument == "save") Save();
    if (argument == "load") Load();
    if (argument == "reset") Storage = "";
}

public void DebugMsg(string msg)
{
    if (debugMode)
        Echo(msg);
}

I also tested a simple script that Echo Storage and in it's Save() function saves data into Storage. First run it was empty, but after recompile there was data saved. switching the block off, changing what text to save, compiling then switching on the block again did change the data.

Should Save() really be called when a program block is switched off/recompiled?

Edit: oops, may have submitted this as feedback instead of bug report.. sorry