Address github copilot code review comments

And other comment/doc improvements.

Author: SkowronskiAndrew

Analyzer.Tests/FileDetectionTests.cs

@@ -185,10 +185,10 @@ public void TryParseMetadata_PlayerDataLevel0_ReturnsExpectedValues()
         Assert.IsNotNull(metadata);
 
         // Verify exact values from the level0 metadata section.
-        // This file was built with Unity 2022.1.20f1 for Windows Standalone (platform 2),
+        // This file was built with Unity 2022.1.20f1 for StandaloneOSX (platform 2),
         // with TypeTrees enabled.
         Assert.That(metadata.UnityVersion, Is.EqualTo("2022.1.20f1"), "Unity version should be 2022.1.20f1");
-        Assert.That(metadata.TargetPlatform, Is.EqualTo(2u), "Target platform should be 2 (Windows Standalone)");
+        Assert.That(metadata.TargetPlatform, Is.EqualTo(2u), "Target platform should be 2 (StandaloneOSX)");
         Assert.IsTrue(metadata.EnableTypeTree, "EnableTypeTree should be true");
 
         // --- TypeTree counts ---

Analyzer/Util/SerializedFileDetector.cs

@@ -22,11 +22,11 @@ public class SerializedFileInfo
 ///
 /// Each entry corresponds to one element of either the regular type list (m_Types) or the
 /// SerializeReference type list (m_RefTypes, version >= 20). Fields that are not applicable
-/// for a given entry use well-defined sentinel values rather than null:
+/// for a given entry use well-defined sentinel values:
 ///   - UnityHash128 fields use IsZero == true to indicate "not present"
 ///   - short ScriptTypeIndex uses -1 to indicate "not a script type"
 ///   - string fields (ClassName, Namespace, AssemblyName) use string.Empty for regular type entries
-///   - TypeDependencies uses an empty array for ref type entries or version < 21
+///   - TypeDependencies uses an empty array for ref type entries or version < 21
 /// </summary>
 public class TypeTreeInfo
 {
@@ -36,15 +36,16 @@ public class TypeTreeInfo
 
     /// <summary>
     /// Unity ClassID for this type (e.g. 114 = MonoBehaviour, 115 = MonoScript).
-    /// Corresponds to m_PersistentTypeID in the file. For ref type entries this is
-    /// typically 0 and less meaningful than ClassName/Namespace/AssemblyName.
+    /// Corresponds to m_PersistentTypeID in the file. For ref type entries this is -1
+    /// and the type is identified by the ClassName/Namespace/AssemblyName triple instead.
     /// </summary>
     public int PersistentTypeID { get; set; }
 
     /// <summary>
-    /// True if this type is stripped: no TypeTree blob is present and the object data
-    /// cannot be fully deserialized without a matching runtime.
+    /// True for types that represent Prefab-stripped objects. In text/YAML files this corresponds to the stripped keyword:
+    /// e.g. --- !u!123 &111 stripped.
     /// </summary>
+    /// <remarks>This field is not related to the presence of a TypeTree blob in the file.</remarks>
     public bool IsStrippedType { get; set; }
 
     /// <summary>
@@ -78,22 +79,23 @@ public class TypeTreeInfo
     /// <summary>
     /// XXH3 content hash of the TypeTree blob. Stored explicitly in the metadata for
     /// version >= 23 (kExtractedTypeTreeSupport). IsZero == true indicates this field
-    /// was not present in the metadata (version &lt; 23 or no inline TypeTree).
+    /// was not present in the metadata (version < 23 or no inline TypeTree).
     /// </summary>
     public UnityHash128 TypeTreeContentHash { get; set; }
 
     /// <summary>
     /// Actual size in bytes of the TypeTree blob for this entry.
     /// 0 when InlineTypeTree is false (stripped, EnableTypeTree=false, or extracted to
-    /// an external store in version >= 23). For version &lt; 23 where the size is not
+    /// an external store in version >= 23). For version < 23 where the size is not
     /// stored explicitly, this is computed by skipping over the blob during parsing.
     /// </summary>
     public uint TypeTreeSerializedSize { get; set; }
 
     /// <summary>
     /// True when the TypeTree blob is present inline in this file's metadata and can be
-    /// read without an external TypeTree store. False when stripped, EnableTypeTree is
-    /// false, or TypeTreeSerializedSize is 0 (extracted, version >= 23).
+    /// read without an external TypeTree store. False when EnableTypeTree is false, or
+    /// TypeTreeSerializedSize is 0 (blob extracted to an external store, version >= 23).
+    /// Note: IsStrippedType is orthogonal and does not affect TypeTree presence.
     /// </summary>
     public bool InlineTypeTree { get; set; }
 
@@ -128,7 +130,7 @@ public class TypeTreeInfo
     /// <summary>
     /// Indices into the SerializedReferenceTypeTrees array representing the
     /// SerializeReference types that objects of this type may reference.
-    /// Empty array for ref type entries or files with version &lt; 21.
+    /// Empty array for ref type entries or files with version < 21.
     /// </summary>
     public int[] TypeDependencies { get; set; } = Array.Empty<int>();
 }
@@ -150,7 +152,7 @@ public class SerializedFileMetadata
 
     /// <summary>
     /// Number of SerializeReference TypeTree entries (m_RefTypes).
-    /// Always 0 for files with version &lt; 20 (kSupportsRefObject).
+    /// Always 0 for files with version < 20 (kSupportsRefObject).
     /// </summary>
     public int SerializedReferenceTypeTreeCount { get; set; }
 
@@ -161,7 +163,7 @@ public class SerializedFileMetadata
 
     /// <summary>
     /// Summary of each SerializeReference type entry.
-    /// Empty array for files with version &lt; 20.
+    /// Empty array for files with version < 20.
     /// </summary>
     public TypeTreeInfo[] SerializedReferenceTypeTrees { get; set; }
 }
@@ -641,7 +643,7 @@ private static void ParseTypeTreeMetadata(BinaryReader reader, SerializedFileInf
     ///     if version >= 23:
     ///       [Hash128 typeTreeContentHash]
     ///       [uint32  typeTreeSize]      (0 = blob extracted to external store)
-    ///     [TypeTree blob]               (present when version &lt; 23 or typeTreeSize > 0)
+    ///     [TypeTree blob]               (present when version < 23 or typeTreeSize > 0)
     ///     if version >= 21:
     ///       if isRefType:  [string className] [string nameSpace] [string asmName]
     ///       else:          [int32 depCount] [int32 * depCount]

Documentation/command-serialized-file.md

@@ -261,13 +261,36 @@ Each element of `typeTrees` and `serializedReferenceTypeTrees` contains per-type
 
 ### Metadata Fields
 
-| Field | Description |
-|-------|-------------|
-| **Unity Version** | The Unity version string used to build this file (e.g. `"2022.1.20f1"`, `"6000.0.65f1"`). |
-| **Target Platform** | Numeric platform identifier. Common values: `2` = OSX Standalone, `9` = iOS, `13` = Android, `19` = Windows Standalone x64. See [BuildTarget](https://docs.unity3d.com/ScriptReference/BuildTarget.html) for details. |
-| **TypeTree Definitions** | Whether the definition of the types are embedded in the file. `Inline` in Editor and TypeTree-enabled builds. `No` in Player builds with TypeTrees stripped (the default). TypeTrees are required for the `objectlist` and `externalrefs` subcommands to show type names. `External` when the TypeTrees are in an external shared file. |
-| **TypeTree Count** | Number of TypeTrees defined in the file. Each TypeTree corresponds to a unique type used by objects in the file. This array is present even when TypeTree definitions are not stored inline. |
-| **RefType Count** | Number of TypeTrees for SerializeReference classes saved in the file. |
+The text and JSON outputs use different field names and representations for some fields.
+
+| Text Field | JSON Field | Description |
+|------------|------------|-------------|
+| **Unity Version** | `unityVersion` | The Unity version string used to build this file (e.g. `"2022.1.20f1"`, `"6000.0.65f1"`). |
+| **Target Platform** | `targetPlatform` | Numeric platform identifier. Common values: `2` = OSX Standalone, `9` = iOS, `13` = Android, `19` = Windows Standalone x64. See [BuildTarget](https://docs.unity3d.com/ScriptReference/BuildTarget.html) for details. |
+| **TypeTree Definitions** | `enableTypeTree` | Whether TypeTree blobs are stored in this file. The text output derives a descriptive string from the raw boolean and the parsed type entries; the JSON output exposes the raw boolean directly. Text values: `No` — TypeTrees absent (default Player build); `Inline` — all TypeTree blobs are embedded in the file (Editor and TypeTree-enabled builds); `External` — TypeTree blobs were extracted to a separate store (version ≥ 23); `Mixed` — entries disagree (unexpected; indicates a parser or file anomaly); `Unknown` — `enableTypeTree` is true but no type entries were parsed. TypeTrees are required for the `objectlist` and `externalrefs` subcommands to show type names. |
+| **TypeTree Count** | `typeTreeCount` | Number of regular (object) type entries recorded in the file. Present even when TypeTree definitions are not stored inline. |
+| **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. |
+
+### Per-Type Entry Fields
+
+Each element of `typeTrees` and `serializedReferenceTypeTrees` in the JSON output contains the following fields:
+
+| JSON Field | Description |
+|------------|-------------|
+| `persistentTypeID` | Unity ClassID (e.g. `114` = MonoBehaviour). `-1` for `[SerializeReference]` entries whose type has no built-in ClassID. |
+| `isStrippedType` | `true` for types representing prefab-stripped objects (the `stripped` keyword in YAML). Orthogonal to TypeTree presence. |
+| `scriptTypeIndex` | Index into the file's MonoScript reference list. `-1` for native Unity types. |
+| `scriptID` | 128-bit hash (MD4 of assembly + namespace + class name) identifying the MonoScript. All-zeros when not applicable. |
+| `oldTypeHash` | Hash of the TypeTree content as originally written; used for compatibility checking at load time. |
+| `typeTreeContentHash` | XXH3 hash of the TypeTree blob. All-zeros for files with version < 23. |
+| `typeTreeSerializedSize` | Byte size of the TypeTree blob for this entry. `0` when `inlineTypeTree` is false. |
+| `inlineTypeTree` | `true` when the TypeTree blob is present inline in the file's metadata. |
+| `className` | C# class name; non-empty only for `[SerializeReference]` entries (version ≥ 21). |
+| `namespaceName` | C# namespace; non-empty only for `[SerializeReference]` entries (version ≥ 21). |
+| `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. |
 
 Notes:
 

UnityDataTool/SerializedFileCommands.cs

@@ -254,8 +254,10 @@ private static void OutputMetadataText(SerializedFileMetadata metadata)
             typeTreeDefinitions = "No";
         else if (metadata.TypeTrees == null || metadata.TypeTrees.Length == 0)
             typeTreeDefinitions = "Unknown";
-        else if (metadata.TypeTrees[0].InlineTypeTree)
+        else if (metadata.TypeTrees.All(t => t.InlineTypeTree))
             typeTreeDefinitions = "Inline";
+        else if (metadata.TypeTrees.Any(t => t.InlineTypeTree))
+            typeTreeDefinitions = "Mixed";  // unexpected: entries disagree on inline vs external
         else
             typeTreeDefinitions = "External";