Parse external file table directly from metadata

Similar to objectlist change

Author: SkowronskiAndrew

Analyzer.Tests/FileDetectionTests.cs

@@ -448,6 +448,28 @@ public void TryParseMetadata_V22PrefabWithSerializedReference_ReturnsExpectedObj
         }
     }
 
+    [Test]
+    public void TryParseMetadata_V22PrefabWithSerializedReference_ReturnsExpectedExternalReferences()
+    {
+        var testFile = Path.Combine(m_TestDataPath, "AssetBundleTypeTreeVariations", "v22",
+            "prefab_with_serializedreference.serializedfile");
+
+        bool headerResult = SerializedFileDetector.TryDetectSerializedFile(testFile, out var headerInfo);
+        Assert.IsTrue(headerResult, "File should be detected as a valid SerializedFile");
+
+        bool result = SerializedFileDetector.TryParseMetadata(testFile, headerInfo, out var metadata, out var errorMessage);
+        Assert.IsTrue(result, $"Metadata parsing should succeed. Error: {errorMessage}");
+        Assert.IsNotNull(metadata);
+
+        Assert.IsNotNull(metadata.ExternalReferences, "ExternalReferences should be populated");
+        Assert.That(metadata.ExternalReferences.Length, Is.EqualTo(1), "Should have 1 external reference");
+
+        var extRef = metadata.ExternalReferences[0];
+        Assert.That(extRef.Path, Is.EqualTo("archive:/CAB-d57a1d89ac0708bf030936c59479c685/CAB-d57a1d89ac0708bf030936c59479c685"));
+        Assert.That(extRef.Guid, Is.EqualTo("00000000000000000000000000000000"));
+        Assert.That(extRef.Type, Is.EqualTo(ExternalReferenceType.NonAssetType));
+    }
+
     #endregion
 
     #region YAML SerializedFile Detection Tests

Analyzer/Util/SerializedFileDetector.cs

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using ExternalReference = UnityDataTools.FileSystem.ExternalReference;
+using ExternalReferenceType = UnityDataTools.FileSystem.ExternalReferenceType;
 using ObjectInfo = UnityDataTools.FileSystem.ObjectInfo;
 
 namespace UnityDataTools.Analyzer.Util;
@@ -173,6 +175,12 @@ public class SerializedFileMetadata
     /// Null until the metadata section has been parsed.
     /// </summary>
     public ObjectInfo[] ObjectList { get; set; }
+
+    /// <summary>
+    /// List of external file references recorded in the file's externals table.
+    /// Null until the metadata section has been parsed.
+    /// </summary>
+    public ExternalReference[] ExternalReferences { get; set; }
 }
 
 /// <summary>
@@ -617,20 +625,28 @@ private static void ParseExtendedMetadata(BinaryReader reader, SerializedFileInf
                 stream.Seek(8, SeekOrigin.Current); // int64 localIdentifierInFile
             }
 
-            // --- Skip the externals list ---
+            // --- External references list ---
             // Per-entry layout:
             //   [null-terminated string tempEmpty]
             //   [uint32[4] guid]   (16 bytes)
             //   [int32 type]
             //   [null-terminated string pathName]
             int externalsCount = BinaryFileHelper.ReadInt32(reader, swap);
+            var externalRefs = new ExternalReference[externalsCount];
             for (int i = 0; i < externalsCount; i++)
             {
-                BinaryFileHelper.ReadNullTermString(reader);          // tempEmpty (empty in practice)
-                stream.Seek(16, SeekOrigin.Current); // Hash128 guid (4 * uint32)
-                stream.Seek(4, SeekOrigin.Current);  // int32 type
-                BinaryFileHelper.ReadNullTermString(reader);          // pathName
+                BinaryFileHelper.ReadNullTermString(reader);  // tempEmpty (empty in practice)
+                var guid = BinaryFileHelper.ReadHash128(reader, swap);
+                int typeInt = BinaryFileHelper.ReadInt32(reader, swap);
+                string pathName = BinaryFileHelper.ReadNullTermString(reader);
+                externalRefs[i] = new ExternalReference
+                {
+                    Path = pathName,
+                    Guid = guid.ToString(),
+                    Type = (ExternalReferenceType)typeInt,
+                };
             }
+            metadata.ExternalReferences = externalRefs;
 
             // m_RefTypes (version >= 20) is not located immediately after m_Types.
             // It appears at the end of the metadata section

UnityDataTool/SerializedFileCommands.cs

@@ -11,39 +11,43 @@ public static class SerializedFileCommands
 {
     public static int HandleExternalRefs(FileInfo filename, OutputFormat format)
     {
-        if (!ValidateSerializedFile(filename.FullName, out _))
+        // External references are read directly from the parsed metadata rather than via UnityFileSystemApi.
+        //
+        // Advantages: works for any modern SerializedFile (version >= 19), including Player builds
+        // that were compiled without TypeTrees — files that UnityFileSystemApi cannot open at all.
+        //
+        // Trade-offs: Files older than version 19 (Unity 2019.1) are not supported by the metadata parser.
+        //
+        // These trade-offs are minor compared to the benefit of handling the common no-TypeTree case,
+        // so there is no need to keep the UnityFileSystemApi code path.
+        if (!ValidateSerializedFile(filename.FullName, out var fileInfo))
             return 1;
 
-        try
+        if (!SerializedFileDetector.TryParseMetadata(filename.FullName, fileInfo, out var metadata, out var errorMessage))
         {
-            using var sf = UnityFileSystem.OpenSerializedFile(filename.FullName);
-            if (format == OutputFormat.Json)
-                OutputExternalRefsJson(sf);
-            else
-                OutputExternalRefsText(sf);
-            return 0;
+            Console.Error.WriteLine($"Error: Failed to parse external references for: {filename.FullName}");
+            Console.Error.WriteLine(errorMessage);
+            return 1;
         }
-        catch (Exception err) when (err is NotSupportedException || err is FileFormatException)
+
+        if (metadata.ExternalReferences == null)
         {
-            Console.Error.WriteLine($"Error opening SerializedFile: {filename.FullName}");
-            Console.Error.WriteLine(err.Message);
+            Console.Error.WriteLine($"Error: External references could not be parsed for: {filename.FullName}");
             return 1;
         }
+
+        if (format == OutputFormat.Json)
+            OutputExternalRefsJson(metadata.ExternalReferences);
+        else
+            OutputExternalRefsText(metadata.ExternalReferences);
+
+        return 0;
     }
 
     public static int HandleObjectList(FileInfo filename, OutputFormat format)
     {
         // The object list is read directly from the parsed metadata rather than via UnityFileSystemApi.
-        //
-        // Advantages: works for any modern SerializedFile (version >= 19), including Player builds
-        // that were compiled without TypeTrees — files that UnityFileSystemApi cannot open at all.
-        //
-        // Trade-offs: type names come from TypeIdRegistry rather than the file's embedded TypeTree,
-        // so uncommon types not covered by the registry are displayed as a numeric TypeId. Files
-        // older than version 19 (Unity 2019.1) are not supported by the metadata parser.
-        //
-        // These trade-offs are minor compared to the benefit of handling the common no-TypeTree case,
-        // so there is no need to keep the UnityFileSystemApi code path.
+        // (See comment in HandleExternalRefs() for the reasons for doing it that way)
         if (!ValidateSerializedFile(filename.FullName, out var fileInfo))
             return 1;
 
@@ -149,24 +153,21 @@ private static bool ValidateSerializedFile(string filePath, out SerializedFileIn
         return true;
     }
 
-    private static void OutputExternalRefsText(SerializedFile sf)
+    private static void OutputExternalRefsText(ExternalReference[] refs)
     {
-        var refs = sf.ExternalReferences;
-
-        for (int i = 0; i < refs.Count; i++)
+        for (int i = 0; i < refs.Length; i++)
         {
             var extRef = refs[i];
             var displayValue = !string.IsNullOrEmpty(extRef.Path) ? extRef.Path : extRef.Guid;
             Console.WriteLine($"Index: {i + 1}, Path: {displayValue}");
         }
     }
 
-    private static void OutputExternalRefsJson(SerializedFile sf)
+    private static void OutputExternalRefsJson(ExternalReference[] refs)
     {
-        var refs = sf.ExternalReferences;
-        var jsonArray = new object[refs.Count];
+        var jsonArray = new object[refs.Length];
 
-        for (int i = 0; i < refs.Count; i++)
+        for (int i = 0; i < refs.Length; i++)
         {
             var extRef = refs[i];
             jsonArray[i] = new