diff --git a/SabreTools.Metadata.DatFiles.Test/DatFileTests.Filtering.cs b/SabreTools.Metadata.DatFiles.Test/DatFileTests.Filtering.cs
index 4cc0e32e..4584b59f 100644
--- a/SabreTools.Metadata.DatFiles.Test/DatFileTests.Filtering.cs
+++ b/SabreTools.Metadata.DatFiles.Test/DatFileTests.Filtering.cs
@@ -59,9 +59,13 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
+
             long sourceIndex = datFile.AddSourceDB(source);
+            datItem.SourceIndex = sourceIndex;
             long machineIndex = datFile.AddMachineDB(machine);
-            _ = datFile.AddItemDB(datItem, machineIndex, sourceIndex, statsOnly: false);
+            datItem.MachineIndex = machineIndex;
+
+            _ = datFile.AddItemDB(datItem, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.ExecuteFilters(filterRunner);
@@ -182,10 +186,17 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem disk = new Disk { Name = "disk" };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
+
             long sourceIndex = datFile.AddSourceDB(source);
+            rom.SourceIndex = sourceIndex;
+            disk.SourceIndex = sourceIndex;
+
             long machineIndex = datFile.AddMachineDB(machine);
-            _ = datFile.AddItemDB(rom, machineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(disk, machineIndex, sourceIndex, statsOnly: false);
+            rom.MachineIndex = machineIndex;
+            disk.MachineIndex = machineIndex;
+
+            _ = datFile.AddItemDB(rom, statsOnly: false);
+            _ = datFile.AddItemDB(disk, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.SetOneRomPerGame();
diff --git a/SabreTools.Metadata.DatFiles.Test/DatFileTests.Splitting.cs b/SabreTools.Metadata.DatFiles.Test/DatFileTests.Splitting.cs
index 88b5c885..10f3293e 100644
--- a/SabreTools.Metadata.DatFiles.Test/DatFileTests.Splitting.cs
+++ b/SabreTools.Metadata.DatFiles.Test/DatFileTests.Splitting.cs
@@ -155,12 +155,22 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
-            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+
             long sourceIndex = datFile.AddSourceDB(source);
-            _ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
+            parentItem.SourceIndex = sourceIndex;
+            matchChildItem.SourceIndex = sourceIndex;
+            noMatchChildItem.SourceIndex = sourceIndex;
+
+            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
+            parentItem.MachineIndex = biosMachineIndex;
+
+            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+            matchChildItem.MachineIndex = deviceMachineIndex;
+            noMatchChildItem.MachineIndex = deviceMachineIndex;
+
+            _ = datFile.AddItemDB(parentItem, statsOnly: false);
+            _ = datFile.AddItemDB(matchChildItem, statsOnly: false);
+            _ = datFile.AddItemDB(noMatchChildItem, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.AddItemsFromChildren(subfolder: true, skipDedup: false);
@@ -210,12 +220,22 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
-            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+
             long sourceIndex = datFile.AddSourceDB(source);
-            _ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
+            parentItem.SourceIndex = sourceIndex;
+            matchChildItem.SourceIndex = sourceIndex;
+            noMatchChildItem.SourceIndex = sourceIndex;
+
+            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
+            parentItem.MachineIndex = biosMachineIndex;
+
+            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+            matchChildItem.MachineIndex = deviceMachineIndex;
+            noMatchChildItem.MachineIndex = deviceMachineIndex;
+
+            _ = datFile.AddItemDB(parentItem, statsOnly: false);
+            _ = datFile.AddItemDB(matchChildItem, statsOnly: false);
+            _ = datFile.AddItemDB(noMatchChildItem, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.AddItemsFromChildren(subfolder: true, skipDedup: true);
@@ -321,12 +341,22 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
-            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+
             long sourceIndex = datFile.AddSourceDB(source);
-            _ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
+            parentItem.SourceIndex = sourceIndex;
+            matchChildItem.SourceIndex = sourceIndex;
+            noMatchChildItem.SourceIndex = sourceIndex;
+
+            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
+            parentItem.MachineIndex = biosMachineIndex;
+
+            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+            matchChildItem.MachineIndex = deviceMachineIndex;
+            noMatchChildItem.MachineIndex = deviceMachineIndex;
+
+            _ = datFile.AddItemDB(parentItem, statsOnly: false);
+            _ = datFile.AddItemDB(matchChildItem, statsOnly: false);
+            _ = datFile.AddItemDB(noMatchChildItem, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.AddItemsFromCloneOfParent();
@@ -448,15 +478,30 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            long deviceMachineIndex = datFile.AddMachineDB(deviceMachine);
-            long slotOptionMachineIndex = datFile.AddMachineDB(slotOptionMachine);
-            long itemMachineIndex = datFile.AddMachineDB(itemMachine);
+
             long sourceIndex = datFile.AddSourceDB(source);
-            _ = datFile.AddItemDB(deviceItem, deviceMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(slotOptionItem, slotOptionMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(datItem, itemMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(deviceRef, itemMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(slotOption, itemMachineIndex, sourceIndex, statsOnly: false);
+            deviceItem.SourceIndex = sourceIndex;
+            slotOptionItem.SourceIndex = sourceIndex;
+            datItem.SourceIndex = sourceIndex;
+            deviceRef.SourceIndex = sourceIndex;
+            slotOption.SourceIndex = sourceIndex;
+
+            long deviceMachineIndex = datFile.AddMachineDB(deviceMachine);
+            deviceItem.MachineIndex = deviceMachineIndex;
+
+            long slotOptionMachineIndex = datFile.AddMachineDB(slotOptionMachine);
+            slotOptionItem.MachineIndex = slotOptionMachineIndex;
+
+            long itemMachineIndex = datFile.AddMachineDB(itemMachine);
+            datItem.MachineIndex = itemMachineIndex;
+            deviceRef.MachineIndex = itemMachineIndex;
+            slotOption.MachineIndex = itemMachineIndex;
+
+            _ = datFile.AddItemDB(deviceItem, statsOnly: false);
+            _ = datFile.AddItemDB(slotOptionItem, statsOnly: false);
+            _ = datFile.AddItemDB(datItem, statsOnly: false);
+            _ = datFile.AddItemDB(deviceRef, statsOnly: false);
+            _ = datFile.AddItemDB(slotOption, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.AddItemsFromDevices(deviceOnly, useSlotOptions);
@@ -562,12 +607,22 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
-            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+
             long sourceIndex = datFile.AddSourceDB(source);
-            _ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
+            parentItem.SourceIndex = sourceIndex;
+            matchChildItem.SourceIndex = sourceIndex;
+            noMatchChildItem.SourceIndex = sourceIndex;
+
+            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
+            parentItem.MachineIndex = biosMachineIndex;
+
+            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+            matchChildItem.MachineIndex = deviceMachineIndex;
+            noMatchChildItem.MachineIndex = deviceMachineIndex;
+
+            _ = datFile.AddItemDB(parentItem, statsOnly: false);
+            _ = datFile.AddItemDB(matchChildItem, statsOnly: false);
+            _ = datFile.AddItemDB(noMatchChildItem, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.AddItemsFromRomOfParent();
@@ -640,11 +695,19 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatItem deviceItem = new Rom();
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            long biosMachineIndex = datFile.AddMachineDB(biosMachine);
-            long deviceMachineIndex = datFile.AddMachineDB(deviceMachine);
+
             long sourceIndex = datFile.AddSourceDB(source);
-            _ = datFile.AddItemDB(biosItem, biosMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(deviceItem, deviceMachineIndex, sourceIndex, statsOnly: false);
+            biosItem.SourceIndex = sourceIndex;
+            deviceItem.SourceIndex = sourceIndex;
+
+            long biosMachineIndex = datFile.AddMachineDB(biosMachine);
+            biosItem.MachineIndex = biosMachineIndex;
+
+            long deviceMachineIndex = datFile.AddMachineDB(deviceMachine);
+            deviceItem.MachineIndex = deviceMachineIndex;
+
+            _ = datFile.AddItemDB(biosItem, statsOnly: false);
+            _ = datFile.AddItemDB(deviceItem, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.RemoveBiosAndDeviceSets();
@@ -761,12 +824,22 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
-            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+
             long sourceIndex = datFile.AddSourceDB(source);
-            _ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
+            parentItem.SourceIndex = sourceIndex;
+            matchChildItem.SourceIndex = sourceIndex;
+            noMatchChildItem.SourceIndex = sourceIndex;
+
+            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
+            parentItem.MachineIndex = biosMachineIndex;
+
+            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+            matchChildItem.MachineIndex = deviceMachineIndex;
+            noMatchChildItem.MachineIndex = deviceMachineIndex;
+
+            _ = datFile.AddItemDB(parentItem, statsOnly: false);
+            _ = datFile.AddItemDB(matchChildItem, statsOnly: false);
+            _ = datFile.AddItemDB(noMatchChildItem, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.RemoveItemsFromCloneOfChild();
@@ -881,12 +954,22 @@ namespace SabreTools.Metadata.DatFiles.Test
             };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
-            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+
             long sourceIndex = datFile.AddSourceDB(source);
-            _ = datFile.AddItemDB(parentItem, biosMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(matchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
-            _ = datFile.AddItemDB(noMatchChildItem, deviceMachineIndex, sourceIndex, statsOnly: false);
+            parentItem.SourceIndex = sourceIndex;
+            matchChildItem.SourceIndex = sourceIndex;
+            noMatchChildItem.SourceIndex = sourceIndex;
+
+            long biosMachineIndex = datFile.AddMachineDB(parentMachine);
+            parentItem.MachineIndex = biosMachineIndex;
+
+            long deviceMachineIndex = datFile.AddMachineDB(childMachine);
+            matchChildItem.MachineIndex = deviceMachineIndex;
+            noMatchChildItem.MachineIndex = deviceMachineIndex;
+
+            _ = datFile.AddItemDB(parentItem, statsOnly: false);
+            _ = datFile.AddItemDB(matchChildItem, statsOnly: false);
+            _ = datFile.AddItemDB(noMatchChildItem, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.RemoveItemsFromRomOfChild();
@@ -915,14 +998,14 @@ namespace SabreTools.Metadata.DatFiles.Test
                 SampleOf = "sampleof"
             };
 
-            DatItem datItem = new Rom
+            DatItem item = new Rom
             {
                 Machine = machine,
                 Source = source
             };
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            datFile.AddItem(datItem, statsOnly: false);
+            datFile.AddItem(item, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.RemoveMachineRelationshipTags();
@@ -948,12 +1031,16 @@ namespace SabreTools.Metadata.DatFiles.Test
                 SampleOf = "sampleof"
             };
 
-            DatItem datItem = new Rom();
+            DatItem item = new Rom();
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
-            long machineIndex = datFile.AddMachineDB(machine);
+
             long sourceIndex = datFile.AddSourceDB(source);
-            _ = datFile.AddItemDB(datItem, machineIndex, sourceIndex, statsOnly: false);
+            item.SourceIndex = sourceIndex;
+            long machineIndex = datFile.AddMachineDB(machine);
+            item.MachineIndex = machineIndex;
+
+            _ = datFile.AddItemDB(item, statsOnly: false);
 
             datFile.BucketBy(ItemKey.Machine);
             datFile.RemoveMachineRelationshipTags();
diff --git a/SabreTools.Metadata.DatFiles.Test/DatFileTests.cs b/SabreTools.Metadata.DatFiles.Test/DatFileTests.cs
index 3dca47c1..2dce442f 100644
--- a/SabreTools.Metadata.DatFiles.Test/DatFileTests.cs
+++ b/SabreTools.Metadata.DatFiles.Test/DatFileTests.cs
@@ -45,8 +45,11 @@ namespace SabreTools.Metadata.DatFiles.Test
             datFile.AddItem(rom, statsOnly: false);
 
             long sourceIndex = datFile.AddSourceDB(source);
+            rom.SourceIndex = sourceIndex;
             long machineIndex = datFile.AddMachineDB(machine);
-            datFile.AddItemDB(rom, machineIndex, sourceIndex, statsOnly: false);
+            rom.MachineIndex = machineIndex;
+
+            datFile.AddItemDB(rom, statsOnly: false);
 
             DatFile created = new Logiqx(datFile, useGame: false);
             created.BucketBy(ItemKey.Machine);
@@ -95,12 +98,16 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             Machine machine = new Machine { Name = "game-1" };
 
-            DatItem datItem = new Rom();
+            DatItem item = new Rom();
 
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
+
             long sourceIndex = datFile.AddSourceDB(source);
+            item.SourceIndex = sourceIndex;
             long machineIndex = datFile.AddMachineDB(machine);
-            _ = datFile.AddItemDB(datItem, machineIndex, sourceIndex, statsOnly: false);
+            item.MachineIndex = machineIndex;
+
+            _ = datFile.AddItemDB(item, statsOnly: false);
 
             datFile.ClearEmpty();
             Assert.Single(datFile.ItemsDB.SortedKeys);
@@ -277,7 +284,7 @@ namespace SabreTools.Metadata.DatFiles.Test
             DatFile datFile = new Logiqx(datFile: null, useGame: false);
             datFile.Header.Name = "name";
             datFile.AddItem(new Rom(), statsOnly: false);
-            datFile.AddItemDB(new Rom(), 0, 0, false);
+            datFile.AddItemDB(new Rom(), statsOnly: false);
 
             datFile.ResetDictionary();
 
@@ -2235,19 +2242,23 @@ namespace SabreTools.Metadata.DatFiles.Test
 
             Rom romA = new Rom
             {
+                SourceIndex = sourceIndex,
+                MachineIndex = machineIndex,
                 Name = "rom",
                 Size = 12345,
                 CRC32 = "crc"
             };
-            long romAIndex = datFile.AddItemDB(romA, machineIndex, sourceIndex, statsOnly: false);
+            long romAIndex = datFile.AddItemDB(romA, statsOnly: false);
 
             Rom romB = new Rom
             {
+                SourceIndex = sourceIndex,
+                MachineIndex = machineIndex,
                 Name = "rom",
                 Size = 12345,
                 CRC32 = "crc"
             };
-            long romBIndex = datFile.AddItemDB(romB, machineIndex, sourceIndex, statsOnly: false);
+            long romBIndex = datFile.AddItemDB(romB, statsOnly: false);
 
             List<KeyValuePair<long, DatItem>> mappings =
             [
diff --git a/SabreTools.Metadata.DatFiles/DatFile.FromMetadata.cs b/SabreTools.Metadata.DatFiles/DatFile.FromMetadata.cs
index 33be66c7..7ff30e81 100644
--- a/SabreTools.Metadata.DatFiles/DatFile.FromMetadata.cs
+++ b/SabreTools.Metadata.DatFiles/DatFile.FromMetadata.cs
@@ -244,8 +244,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Adjuster(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -256,8 +259,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Archive(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -268,8 +274,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new BiosSet(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -280,8 +289,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Chip(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -292,8 +304,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Configuration(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -304,8 +319,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Device(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -316,8 +334,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(items, item =>
                 {
                     var datItem = new DeviceRef(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -328,8 +349,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new DipSwitch(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -340,8 +364,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Disk(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -352,16 +379,22 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Display(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
             if (item.Driver is not null && filterRunner?.Run(item.Driver) != false)
             {
                 var datItem = new Driver(item.Driver, machine, source);
+                // datItem.MachineIndex = machineIndex;
+                // datItem.SourceIndex = sourceIndex;
+
                 AddItem(datItem, statsOnly);
-                // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                // AddItemDB(datItem, statsOnly);
             }
 
             if (item.Dump is not null)
@@ -370,6 +403,8 @@ namespace SabreTools.Metadata.DatFiles
                 for (int i = 0; i < items.Length; i++)
                 {
                     var datItem = new Rom(items[i], machine, source, i);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
 
                     var original = items[i].Original;
                     if (original is not null)
@@ -384,7 +419,7 @@ namespace SabreTools.Metadata.DatFiles
                     if (datItem.Name is not null)
                     {
                         AddItem(datItem, statsOnly);
-                        // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                        // AddItemDB(datItem, statsOnly);
                     }
                 }
             }
@@ -396,8 +431,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Feature(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -408,16 +446,22 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Info(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
             if (item.Input is not null && filterRunner?.Run(item.Input) != false)
             {
                 var datItem = new Input(item.Input, machine, source);
+                // datItem.MachineIndex = machineIndex;
+                // datItem.SourceIndex = sourceIndex;
+
                 AddItem(datItem, statsOnly);
-                // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                // AddItemDB(datItem, statsOnly);
             }
 
             if (item.Media is not null)
@@ -427,8 +471,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Media(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -445,8 +492,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Port(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -457,8 +507,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new RamOption(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -469,8 +522,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Release(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -481,11 +537,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Rom(item, machine, source);
-                    datItem.Source = source;
-                    datItem.CopyMachineInformation(machine);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
 
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -496,8 +552,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Sample(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -508,8 +567,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new SharedFeat(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -520,8 +582,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(items, item =>
                 {
                     var datItem = new Slot(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -532,8 +597,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new SoftwareList(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
 
@@ -541,7 +609,7 @@ namespace SabreTools.Metadata.DatFiles
             {
                 var datItem = new Sound(item.Sound, machine, source);
                 AddItem(datItem, statsOnly);
-                // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                // AddItemDB(datItem, statsOnly);
             }
 
             if (item.Video is not null)
@@ -551,8 +619,11 @@ namespace SabreTools.Metadata.DatFiles
                 Array.ForEach(filtered, item =>
                 {
                     var datItem = new Display(item, machine, source);
+                    // datItem.MachineIndex = machineIndex;
+                    // datItem.SourceIndex = sourceIndex;
+
                     AddItem(datItem, statsOnly);
-                    // AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                    // AddItemDB(datItem, statsOnly);
                 });
             }
         }
@@ -602,6 +673,9 @@ namespace SabreTools.Metadata.DatFiles
 
                             // Convert the item
                             var romItem = new Rom(rom, machine, source);
+                            // romItem.MachineIndex = machineIndex;
+                            // romItem.SourceIndex = sourceIndex;
+
                             long? size = romItem.Size;
 
                             // If the rom is a continue or ignore
@@ -630,7 +704,7 @@ namespace SabreTools.Metadata.DatFiles
                         foreach (var romItem in addRoms)
                         {
                             AddItem(romItem, statsOnly);
-                            // AddItemDB(romItem, machineIndex, sourceIndex, statsOnly);
+                            // AddItemDB(romItem, statsOnly);
                         }
                     }
                 }
@@ -656,9 +730,11 @@ namespace SabreTools.Metadata.DatFiles
                                 PartInterface = item.Interface,
                                 PartName = item.Name,
                             };
+                            // diskItem.MachineIndex = machineIndex;
+                            // diskItem.SourceIndex = sourceIndex;
 
                             AddItem(diskItem, statsOnly);
-                            // AddItemDB(diskItem, machineIndex, sourceIndex, statsOnly);
+                            // AddItemDB(diskItem, statsOnly);
                         }
                     }
                 }
@@ -677,9 +753,11 @@ namespace SabreTools.Metadata.DatFiles
                             PartInterface = item.Interface,
                             PartName = item.Name,
                         };
+                        // dipSwitchItem.MachineIndex = machineIndex;
+                        // dipSwitchItem.SourceIndex = sourceIndex;
 
                         AddItem(dipSwitchItem, statsOnly);
-                        // AddItemDB(dipSwitchItem, machineIndex, sourceIndex, statsOnly);
+                        // AddItemDB(dipSwitchItem, statsOnly);
                     }
                 }
 
@@ -699,9 +777,11 @@ namespace SabreTools.Metadata.DatFiles
                             Source = source,
                         };
                         partFeatureItem.CopyMachineInformation(machine);
+                        // partFeatureItem.MachineIndex = machineIndex;
+                        // partFeatureItem.SourceIndex = sourceIndex;
 
                         AddItem(partFeatureItem, statsOnly);
-                        // AddItemDB(partFeatureItem, machineIndex, sourceIndex, statsOnly);
+                        // AddItemDB(partFeatureItem, statsOnly);
                     }
                 }
             }
diff --git a/SabreTools.Metadata.DatFiles/DatFile.cs b/SabreTools.Metadata.DatFiles/DatFile.cs
index 9eab8315..cd14cfb9 100644
--- a/SabreTools.Metadata.DatFiles/DatFile.cs
+++ b/SabreTools.Metadata.DatFiles/DatFile.cs
@@ -221,16 +221,10 @@ namespace SabreTools.Metadata.DatFiles
         /// Add a DatItem to the dictionary after validation
         /// </summary>
         /// <param name="item">Item data to validate</param>
-        /// <param name="machineIndex">Index of the machine related to the item</param>
-        /// <param name="sourceIndex">Index of the source related to the item</param>
         /// <param name="statsOnly">True to only add item statistics while parsing, false otherwise</param>
         /// <returns>The index for the added item, -1 on error</returns>
-        public long AddItemDB(DatItem item, long machineIndex, long sourceIndex, bool statsOnly)
+        public long AddItemDB(DatItem item, bool statsOnly)
         {
-            // TODO: Have the callers of this method set them instead
-            item.MachineIndex = machineIndex;
-            item.SourceIndex = sourceIndex;
-
             return ItemsDB.AddItem(item, statsOnly);
         }
 
diff --git a/SabreTools.Metadata.DatFiles/Formats/SabreJSON.cs b/SabreTools.Metadata.DatFiles/Formats/SabreJSON.cs
index c95d87b9..58fa7251 100644
--- a/SabreTools.Metadata.DatFiles/Formats/SabreJSON.cs
+++ b/SabreTools.Metadata.DatFiles/Formats/SabreJSON.cs
@@ -391,9 +391,12 @@ namespace SabreTools.Metadata.DatFiles.Formats
                     return;
 
                 datItem.CopyMachineInformation(machine);
+                datItem.MachineIndex = machineIndex;
                 datItem.Source = source;
+                datItem.SourceIndex = sourceIndex;
+
                 AddItem(datItem, statsOnly);
-                AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
+                // AddItemDB(datItem, statsOnly);
             }
         }
 
diff --git a/SabreTools.Metadata.DatFiles/Formats/SabreXML.cs b/SabreTools.Metadata.DatFiles/Formats/SabreXML.cs
index 99c18d65..fb7f8c2f 100644
--- a/SabreTools.Metadata.DatFiles/Formats/SabreXML.cs
+++ b/SabreTools.Metadata.DatFiles/Formats/SabreXML.cs
@@ -223,9 +223,12 @@ namespace SabreTools.Metadata.DatFiles.Formats
                             }
 
                             item.CopyMachineInformation(machine);
+                            item.MachineIndex = machineIndex;
                             item.Source = source;
+                            item.SourceIndex = sourceIndex;
+
                             AddItem(item, statsOnly);
-                            // AddItemDB(item, machineIndex, sourceIndex, statsOnly);
+                            // AddItemDB(item, statsOnly);
                         }
 
                         xtr.Skip();