Parse and expose ScriptType table

Final step of fully parsing the metadata section of serialized files

Author: SkowronskiAndrew

Analyzer.Tests/FileDetectionTests.cs

@@ -364,6 +364,16 @@ public void TryParseMetadata_V22PrefabWithSerializedReference_ReturnsExpectedTyp
         Assert.That(monoBehaviour.TypeDependencies[0], Is.EqualTo(0),
             "MonoBehaviour should record dependency on SerializedReference");
 
+        // --- Script types ---
+        // ScriptTypeIndex=0 on the MonoBehaviour entry above means it is backed by ScriptTypes[0].
+        // The MonoScript lives in external file #1 (the companion monoscriptbundle).
+        Assert.IsNotNull(metadata.ScriptTypes, "ScriptTypes should be populated");
+        Assert.That(metadata.ScriptTypes.Length, Is.EqualTo(1), "Should have 1 script type entry");
+        Assert.That(metadata.ScriptTypes[0].FileID, Is.EqualTo(1),
+            "ScriptTypes[0].FileID should be 1 (first external reference)");
+        Assert.That(metadata.ScriptTypes[0].PathID, Is.EqualTo(3225487681952536265L),
+            "ScriptTypes[0].PathID should match the MonoScript object ID in monoscriptbundle");
+
         // --- SerializedReference type entry ---
         Assert.That(metadata.SerializedReferenceTypeTrees.Length, Is.EqualTo(1));
         var refType = metadata.SerializedReferenceTypeTrees[0];

Analyzer/Util/SerializedFileDetector.cs

@@ -138,6 +138,24 @@ public class TypeTreeInfo
     public int[] TypeDependencies { get; set; } = Array.Empty<int>();
 }
 
+/// <summary>
+/// A reference to a MonoScript object that backs a C# MonoBehaviour type recorded in this file.
+/// Corresponds to one entry in the file's m_ScriptTypes list.
+/// </summary>
+public class ScriptType
+{
+    /// <summary>
+    /// Index into the file's external references list, identifying which SerializedFile contains
+    /// the MonoScript object. 0 = this file itself; 1+ = 1-based index into the externals list.
+    /// </summary>
+    public int FileID { get; set; }
+
+    /// <summary>
+    /// The object ID (localIdentifierInFile) of the MonoScript within the identified file.
+    /// </summary>
+    public long PathID { get; set; }
+}
+
 /// <summary>
 /// Information extracted from the beginning of a Unity SerializedFile metadata section.
 /// </summary>
@@ -170,6 +188,14 @@ public class SerializedFileMetadata
     /// </summary>
     public TypeTreeInfo[] SerializedReferenceTypeTrees { get; set; }
 
+    /// <summary>
+    /// List of MonoScript references for the C# types used in this file.
+    /// Each entry points to the MonoScript object (in this file or an external file) that backs
+    /// a C# MonoBehaviour-derived type whose ScriptTypeIndex is the index of that entry here.
+    /// Null until the metadata section has been parsed.
+    /// </summary>
+    public ScriptType[] ScriptTypes { get; set; }
+
     /// <summary>
     /// List of all objects recorded in the file's object table.
     /// Null until the metadata section has been parsed.
@@ -612,18 +638,22 @@ private static void ParseExtendedMetadata(BinaryReader reader, SerializedFileInf
             }
             metadata.ObjectList = objectList;
 
-            // --- Skip the script type list ---
+            // --- Script type list ---
+            // Each entry points to the MonoScript object that backs a C# MonoBehaviour-derived type.
             // Per-entry layout (version >= 14, applies to all our versions):
-            //   [int32 localSerializedFileIndex]
+            //   [int32 localSerializedFileIndex]   (FileID: 0 = this file, 1+ = external ref index)
             //   [4-byte alignment relative to metadata start]
-            //   [int64 localIdentifierInFile]
+            //   [int64 localIdentifierInFile]      (PathID: object ID within the identified file)
             int scriptTypeCount = BinaryFileHelper.ReadInt32(reader, swap);
+            var scriptTypes = new ScriptType[scriptTypeCount];
             for (int i = 0; i < scriptTypeCount; i++)
             {
-                stream.Seek(4, SeekOrigin.Current); // int32 localSerializedFileIndex
+                int fileID = BinaryFileHelper.ReadInt32(reader, swap);
                 BinaryFileHelper.AlignTo4(stream, metadataOffset);
-                stream.Seek(8, SeekOrigin.Current); // int64 localIdentifierInFile
+                long pathID = BinaryFileHelper.ReadInt64(reader, swap);
+                scriptTypes[i] = new ScriptType { FileID = fileID, PathID = pathID };
             }
+            metadata.ScriptTypes = scriptTypes;
 
             // --- External references list ---
             // Per-entry layout:

Documentation/command-serialized-file.md

@@ -253,11 +253,12 @@ UnityDataTool serialized-file metadata level0 --format json
   "typeTreeCount": 6,
   "serializedReferenceTypeTreeCount": 0,
   "typeTrees": [ ... ],
-  "serializedReferenceTypeTrees": [ ... ]
+  "serializedReferenceTypeTrees": [ ... ],
+  "scriptTypes": [ ... ]
 }
 ```
 
-Each element of `typeTrees` and `serializedReferenceTypeTrees` contains per-type details including hash values, TypeTree blob size, inline/external flag, and (for SerializeReference types) the C# class identity.
+Each element of `typeTrees` and `serializedReferenceTypeTrees` contains per-type details including hash values, TypeTree blob size, inline/external flag, and (for SerializeReference types) the C# class identity. Each element of `scriptTypes` contains the file and object ID of the backing MonoScript asset.
 
 ### Metadata Fields
 
@@ -272,6 +273,7 @@ The text and JSON outputs use different field names and representations for some
 | **RefType Count** | `serializedReferenceTypeTreeCount` | Number of type entries for `[SerializeReference]` types recorded in the file. Always `0` for files with version < 20. |
 | *(JSON only)* | `typeTrees` | Array of per-type detail objects for the regular type entries. `null` when parsing failed or was not attempted. See **Per-Type Entry Fields** below. |
 | *(JSON only)* | `serializedReferenceTypeTrees` | Array of per-type detail objects for the `[SerializeReference]` type entries. Empty array for files with version < 20. See **Per-Type Entry Fields** below. |
+| *(JSON only)* | `scriptTypes` | Array of MonoScript references for the C# types used in this file. Each entry's index corresponds to the `scriptTypeIndex` field of a type entry in `typeTrees`. See **Script Type Entry Fields** below. |
 
 ### Per-Type Entry Fields
 
@@ -292,6 +294,15 @@ Each element of `typeTrees` and `serializedReferenceTypeTrees` in the JSON outpu
 | `assemblyName` | Assembly name; non-empty only for `[SerializeReference]` entries (version ≥ 21). |
 | `typeDependencies` | Array of indices into `serializedReferenceTypeTrees` listing which `[SerializeReference]` types objects of this type may hold. Empty for `[SerializeReference]` entries or files with version < 21. |
 
+### Script Type Entry Fields
+
+Each element of `scriptTypes` in the JSON output contains:
+
+| JSON Field | Description |
+|------------|-------------|
+| `fileID` | Index into the file's external references list identifying which SerializedFile contains the MonoScript asset. `0` = this file itself; `1`+ = 1-based index into the `externalrefs` list. |
+| `pathID` | The object ID (`localIdentifierInFile`) of the MonoScript within the identified file. Corresponds to the `id` field shown by `sf objectlist` on that file. |
+
 Notes:
 
 * For SerializedFiles inside AssetBundles the Unity Version is frequently stripped ("0.0.0").  See [BuildAssetBundleOptions.AssetBundleStripUnityVersion](https://docs.unity3d.com/ScriptReference/BuildAssetBundleOptions.AssetBundleStripUnityVersion.html).

UnityDataTool/SerializedFileCommands.cs

@@ -271,6 +271,7 @@ private static void OutputMetadataJson(SerializedFileMetadata metadata)
             serializedReferenceTypeTreeCount = metadata.SerializedReferenceTypeTreeCount,
             typeTrees = metadata.TypeTrees?.Select(TypeTreeInfoToJson).ToArray(),
             serializedReferenceTypeTrees = metadata.SerializedReferenceTypeTrees?.Select(TypeTreeInfoToJson).ToArray(),
+            scriptTypes = metadata.ScriptTypes?.Select(s => new { fileID = s.FileID, pathID = s.PathID }).ToArray(),
         };
 
         var json = JsonSerializer.Serialize(jsonObject, new JsonSerializerOptions { WriteIndented = true });