v1.0.0-rc.9

The last prerelease before 1.0.0. The notes below list what changed since 1.0.0-rc.8.

Added

• Type dropdowns show the type's icon left of its name: the [TypeSelectorDisplay] icon, else Unity's icon for the type. Type icons under Appearance in the Settings tab turns them off.
• Field stripes under Appearance in the Settings tab hides the status stripe left of [SerializeReference], [TypeSelector], SerializableType and SerializableMonoScript fields in the Inspector, and the gutter a shared reference leaves for it. The notices under the fields stay.
• In the Settings tab the Right arrow turns a focused switch on and the Left arrow turns it off; Enter still flips it.
• Alt+Shift+R (Option+Shift+R on macOS) opens Asset References on the selected asset from any Editor window. Rebind it as Aspid FastTools/Open Asset References in the Shortcuts window.
• The FastTools window switches tabs with Alt+Left and Alt+Right (Option on macOS), next to Ctrl+Tab. Rebind them under Aspid FastTools/Window in the Shortcuts window.
• RemoveChildren and RemoveChildrenIf remove several children in one call and take the same params, IEnumerable, List and ReadOnlySpan overloads as AddChildren.
• AddClasses, RemoveClasses, ToggleClasses and EnableClasses change several USS classes in one call and take the same params, IEnumerable, List and ReadOnlySpan overloads as AddChildren. An IEnumerable may read GetClasses() of the same element. EnableClasses takes the flag first: EnableClasses(isFree, "selected", "free").
• AddAspidWindowTheme() gives an element of your own editor window the colours of the FastTools windows: the palette of the editor skin and the theme picked under Appearance, a theme of the project included. The element follows a new pick at once, and the style sheets you add after it read the --aspid-colors-* tokens.
• TypeSelectorWindow.Show takes a style sheet. The picker then takes the FastTools palette and theme, light on the light skin, in place of the colours of Unity's popups, and the sheet comes on top, so the picker can match the window that opens it.
• InsertStyleSheet inserts a style sheet at an index, EnableStyleSheet(sheet, enable) adds or removes it, and ClearStyleSheets removes every style sheet.
• AddStyleSheets, InsertStyleSheets, RemoveStyleSheets and EnableStyleSheets take several style sheets, with the same overloads as AddClasses.
• Every style sheet method has a …FromResources variant; the plural ones take several paths: AddStyleSheetsFromResources("UI/Base", "UI/Dark").
• Every class and style sheet method has an …If variant, for example AddClassIf, EnableClassIf and AddStyleSheetFromResourcesIf.
• ToggleButtonGroup gets typed SetValue, AddValueChanged, RemoveValueChanged and SetLabel overloads for ToggleButtonGroupState, so calls such as AddValueChanged(evt => …) need no type arguments.
• GUIDField (Unity 6000.4+) gets the same chainable setters as Hash128Field: SetLabel, SetReadOnly, SetMaxLength and the other text-input and text-selection setters, so SetLabel("Id") needs no type arguments.
• RectIntField gets a typed SetLabel, so SetLabel("Area") needs no type arguments, as on RectField.
• DropdownField, PopupField<T>, RadioButtonGroup and MinMaxSlider get chainable setters: SetChoices for the first three, SetIndex, SetFormatListItemCallback and SetFormatSelectedValueCallback for the popup fields, and SetLowLimit, SetHighLimit, SetMinValue and SetMaxValue for MinMaxSlider. SetChoices needs no type arguments; DropdownField.SetChoices also takes any IEnumerable<string>, such as an array, and copies it. The other setters of PopupField<T> need them (SetIndex<PopupField<int>, int>(1)); DropdownField has overloads without them.
• SetBackgroundImage takes a Sprite or a VectorImage as well as a StyleBackground: icon.SetBackgroundImage(sprite).
• From Unity 6000.6, SetTextSelf also takes an int, a long, a ulong, a float with a format, a ReadOnlySpan<char>, a StringBuilder or a char[] slice and sets the text through Unity's allocation-free TextElement.SetText, so text that changes every frame needs no ToString(). An element that is not attached to a panel yet gets the string instead, without Unity's warning.
• SetRootItemsSelf fills a TreeView or MultiColumnTreeView in a chain: tree.SetAutoExpand(true).SetRootItemsSelf(items).
• ScrollView, TabView, Tab and TwoPaneSplitView get chainable setters. ScrollView: SetMode, SetHorizontalScrollerVisibility, SetVerticalScrollerVisibility, SetScrollOffset, SetHorizontalPageSize, SetVerticalPageSize, SetMouseWheelScrollSize, SetScrollDecelerationRate, SetElasticity, SetElasticAnimationIntervalMs, SetTouchScrollBehavior, SetNestedInteractionKind. TabView: SetActiveTab, SetSelectedTabIndex, SetReorderable, AddActiveTabChanged, AddTabReordered, AddTabClosed and their Remove… pairs. Tab: SetLabel, SetIconImage, SetCloseable, AddSelected, AddClosing, AddClosed and their Remove… pairs. TwoPaneSplitView: SetFixedPaneIndex, SetFixedPaneInitialDimension, SetOrientation.
• ListView, TreeView and the other collection views get SetShowBorder.
• RegisterCallbackSelf, RegisterCallbackOnceSelf (the callback runs for one event) and UnregisterCallbackSelf add and remove an event callback in a chain, with the userArgs and TrickleDown parameters of Unity's RegisterCallback: button.RegisterCallbackSelf((PointerEnterEvent evt) => Hover()).SetTooltip("Apply").
• TextField, IntegerField, LongField, UnsignedIntegerField, UnsignedLongField, FloatField, DoubleField and Hash128Field get chainable setters: SetMaxLength, SetMaskChar, SetDelayed, SetReadOnly, SetPassword, SetPlaceholder, SetHidePlaceholderOnFocus, SetKeyboardType, SetAutoCorrection, SetHideMobileInput, SetHideSoftKeyboard, and for text selection SetSelectable, SetSelectAllOnFocus, SetSelectAllOnMouseUp, SetDoubleClickSelectsWord, SetTripleClickSelectsLine, SetCursorIndex, SetSelectIndex, AddOnCursorIndexChange / RemoveOnCursorIndexChange, AddOnSelectIndexChange / RemoveOnSelectIndexChange. The ITextEdition and ITextSelection setters do not reach these fields. Other value types use TextInputBaseFieldExtensions and TextInputBaseFieldTextSelectionExtensions.
• TextField gets SetMultiline and SetVerticalScrollerVisibilitySelf; the name has Self because Unity's own obsolete SetVerticalScrollerVisibility hides an extension of that name. IntegerField, LongField, UnsignedIntegerField, UnsignedLongField, FloatField and DoubleField get SetFormatString; other TextValueField<T> types use SetFormatString<TField, TValue> of TextInputBaseFieldExtensions.
• Added AndApplyWithoutUndo counterparts for every SerializedProperty setter with immediate application, including SetValue overloads, object references, enums, and array size helpers.
• SetEnum, SetEnumAndApply and SetEnumAndApplyWithoutUndo write an enum value to a SerializedProperty, and SetValue(Rarity.Rare) calls them. SetEnumIndex takes an index into the enum entries, not a value: for Rare = 20 the call SetEnumIndex((int)Rarity.Rare) picks the wrong entry.
• On Unity 6000.4 and later, SetGuid, SetGuidAndApply, SetGuidAndApplyWithoutUndo and the SetValue overloads write a GUID field; it needed SetBoxed before.
• Settings and Preferences → Aspid.FastTools get an Appearance section. Its Theme dropdown recolors the FastTools windows and the type picker: Default (near-black cards, green accent), Venom (the blue-black palette of the documentation site with its blue accent) or Unity (the greys of Unity's editor skin, so the windows read as editor panels), each with a light variant for the light editor skin. The success status stays green in all of them. The accent of links, focus and hover borders, the active tab, buttons, switches, and the Welcome title and logo moved into its own --aspid-colors-accent-* and --aspid-icons-accent tokens, so a theme can change it apart from the success status; --aspid-colors-surface-control and --aspid-colors-surface-field set the fills of the buttons and drop-downs, and of the value boxes, in the settings; --aspid-radius-card and --aspid-radius-control set their corners, --aspid-colors-slider-track the slider track, --aspid-colors-dots-1 to -3 colour the dots behind the windows, and --aspid-dots-radius: 0 hides them. Below the built-in themes the dropdown lists the themes of the project, the .uss sheets in Assets with the AspidFastToolsTheme label, and Create theme… at its end copies the current theme into a new sheet, labels it and picks it. A theme of the project is picked for that project, a built-in one for every project on the machine. Picking a theme recolors the windows that are already open, and a sheet picked earlier as the theme override becomes the theme of the project. In the Settings tab, Enter opens the dropdown and the Left and Right arrows step through the themes.
• Analyzer AFT0009 (warning) — two [TypeSelector] base types have no type in common, so the selector is empty.
• Analyzer AFT0012 (warning) — [TypeSelector] on a field Unity does not serialize, so the Inspector never shows it: a non-public field without [SerializeField] or [SerializeReference], an auto-property without [field: SerializeField], or a static, const, readonly or [NonSerialized] field.
• Analyzer AFT0010 (warning) — a this.Marker() call opens no profiler marker because the generator cannot support it: it is written in a private or protected type (or a type nested in one), in an interface (a default interface method) or in a type that reuses a type parameter name of a containing type; its receiver is of another type (other.Marker(), calls in static classes); it has an explicit argument (this.Marker(5)) or a type argument; or it is this?.Marker(), the static call form, a method group or a call inside an expression tree. The generator emits no marker for such calls.
• Analyzer AFT0011 (warning) — the scope of this.Marker() is discarded (this.Marker(); as a statement, _ = this.Marker();, a local nothing reads), so the sample it begins never ends.
• SerializeReferenceIMGUIList.Draw(listProperty, label, baseTypes) takes the element type from the list field, like SerializeReferenceEditorGUI.CreateList; the overload with elementType stays.
• EnumValues<TEnum, TValue> and EnumValues<TValue> get TryGetValue, which tells a matching row from the Default Value fallback, and Count, the number of rows that foreach yields. EnumValues<TValue> also gets GetValue<TEnum> and TryGetValue<TEnum>, which take the key without boxing it; a call such as table.GetValue(damageType) binds to them after a recompile.
• Analyzer AFT0013 (warning) — a this.Marker() scope stays open across yield return or await: the coroutine or async method resumes in a later frame or on another thread, so the Profiler gets unbalanced samples.
• Analyzer AFT0014 (warning) — a WithName name the generator cannot read at compile time, such as a variable, so the marker keeps the member name.
• Every analyzer diagnostic has a description of the fix and a help link to its documentation page; Rider and Visual Studio used to open a web search for the ID.
• Missing [SerializeReference] types set by prefab instance overrides (prefab variants, nested prefabs, prefab instances in scenes) are now found: the build / CI gate counts them as missing types, Project References lists them in a Prefab instance overrides card, and the delete guard and breakage detection count them. They are not rewritten; fix them on the instance or revert the override. An old name that [MovedFrom] maps is listed there as a pending migration, since Migrate all does not rewrite overrides. The CI report gains a trailing origin column, override for these rows.
• Assets → Aspid 🐍 → FastTools → Asset References, in the main menu and the right-click menu of the Project window, opens Asset References on the selected prefab, ScriptableObject, scene or prefab instance; the item is disabled for any other selection.
• -srGateStrict makes the CI check count the files it could not check (unfetched Git LFS files, binary assets that can hold references) as violations, so under Fail a run without git lfs pull no longer passes with exit code 0.
• The CI report gains trailing ns and asm columns with the stored namespace and assembly of a MissingType row. The build and CI logs name a missing type with its namespace (Game.Pistol, not Pistol), so same-named classes can be told apart.
• A [SerializeReference] field whose class or own data is overridden on a prefab instance has a bold label, and its header menu offers Revert and Apply to Prefab 'Name', as Unity's own fields do. A change inside a nested reference marks only the changed field, and Apply is not offered on a prefab variant selected in Project. The blue override bar is not drawn, and a selection of several objects shows neither.
• A SerializableType or SerializableMonoScript field or a [TypeSelector] string whose stored type no longer resolves shows a Missing type notice under the field. Fix opens the type picker to choose a replacement. When the class only moved to another namespace or assembly and exactly one compatible type has its name, a → TypeName button replaces the stored name in one click. The caption shows the type name without its assembly, <Missing Game.Combat.Spear>, and the tooltip shows the whole stored name.
• TypeField.AssemblyQualifiedName returns the stored name of a missing type, for which value is null, so a custom editor can save the name back unchanged. TypeField.ExcludeEditorOnlyTypes is now public: an unbound field can leave out types from editor-only assemblies, as a bound field on a runtime object does.
• SerializableType, SerializableMonoScript and their generic variants get IsEmpty (no type is stored) and IsMissing (a name is stored but no longer resolves); Type is null in both cases. Unity fills a serialized field with an empty wrapper when it loads an asset, a scene or a prefab, so field == null alone misses an unset one: test field is null || field.IsEmpty.
• Missing SerializableType and SerializableMonoScript names are found across the project. Project References → Scan Project lists them in type name groups with Fix all, Smart Fix and Undo; prefab instance overrides and fields in managed references are rewritten too. The build / CI gate reports them as MissingTypeName rows, with the stored name in the className column and the wrapper field in fieldPath, and breakage detection reports a name that stops resolving. [TypeSelector] strings are still checked only in the Inspector.
• The folder button next to a SerializableType, SerializableMonoScript, [TypeSelector] or [SerializeReference] field, and OpenInScriptEditor, open the API reference of a type that ships with Unity and has no script in the project: a UnityEngine, UnityEditor or Unity type such as CharacterController opens its Scripting API page on docs.unity3d.com for your Editor version, a System type its page on learn.microsoft.com. The button used to only log a warning for such a type.

Changed

• The IMGUI drawer of EnumValues looks like the UI Toolkit one: the field name sits above the type field, which spans the full width, a line separates the header, Default Value is no longer indented, and the Values header is plain text instead of bold on a band.
• Excluded scan folders in the Settings tab reads as one of Unity's lists: its caption and the folders share one framed block, each folder has a − at the end of its row, and the last row (or the List is empty row) has the +. A click selects a folder and a double click picks another one for it. With the keyboard, Enter or Delete on a focused folder removes it, and its − lights up while it has the focus.
• The minimum Unity version is now 6000.0.53f1 instead of 6000.0.0f1. The package uses UI Toolkit APIs that later 6000.0 patches added (IStyle.unityEditorTextRenderingMode, IStyle.unitySliceType, UxmlElement.libraryPath), so it did not compile on earlier patches.
• The package no longer ships the Documentation folder with its pages and images, so they are not imported into your project; the documentation lives on the site: https://vpdpersonal.github.io/Aspid.FastTools/. The samples ship no README either: a sample description in the Package Manager ends with a link to its tutorial on the site, and the sample card on the Welcome tab shows it as a Tutorial link.
• The package README.md no longer gives the git URL, so an Asset Store buyer does not add a second copy of the package; the git URL install stays on the site.
• The Agent Skills for this package moved from the aspid-fasttools Claude Code plugin in Aspid.Claude.Plugins into this repository (skills/). Install them into Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI or another agent with npx skills add VPDPersonal/Aspid.FastTools#skills, or #skills-preview for a preview version: npx skills update then follows the releases of that channel, never main; the plugin is no longer published. A plugin you installed stays on your machine and teaches the agent API that no longer exists: remove it in Claude Code with /plugin uninstall aspid-fasttools@aspid-claude-plugins.
• The samples have a new look. Every sample ships a Fonts folder with IBM Plex Serif and iA Writer Quattro S, and EnumValues and EditorTools also with IBM Plex Mono, under the SIL Open Font License 1.1 (the license texts lie next to the fonts, and Third-Party Notices.txt in the package root lists the fonts with their licenses and paths). The scene samples (EnumValues, Types, SerializeReferences, ProfilerMarkers) also ship a Materials folder with colour materials and a Shaders folder with a small Studio shader. The Ability Catalog of the EditorTools sample uses the fonts through SampleFonts.uss and takes the FastTools theme through AddAspidWindowTheme(); its Effect field opens the type picker in place of the Change… button and shows the [TypeSelectorDisplay] name and icon of the effect, + replaces Create, Reset to defaults, shown while the cost or the cooldown differs from its default, replaces Halve cooldown, +5 MP, and the buttons of a row select its asset or move it to the trash. The sample no longer has a custom inspector: an AbilityConfig asset shows in Unity's default Inspector. The samples grow from about 0.2 MB to about 3 MB, most of it font copies: a sample is imported on its own, so each one carries its own.
• The five samples are simplified and listed in the order Types, SerializeReferences, EnumValues, ProfilerMarkers, EditorTools. They keep the scenes and the look above, while their C# shrinks from about 2,660 lines to about 1,560: no comments, tooltips or Debug.Log, one type per file, the scripts in a Scripts folder beside their assembly definition with related types in subfolders, and fewer classes that only filled out the demos. No sample needs the Physics module any more, and the scenes have no lights or colliders. SerializeReferences ships no broken assets: its presets, the broken prefab and the IMGUI preset inspector are gone, and its tutorial breaks a reference by renaming a class instead.
• Renamed GetScriptName() to GetDisplayName() and GetScriptNameWithIndex() to GetDisplayNameWithIndex(); update existing calls to the new names. Both methods now return string.Empty for null or destroyed objects. Component indexing uses a pooled list instead of temporary arrays and LINQ.
• Renamed VisualElement extensions; update existing calls:
  • SetIsDelayed / SetIsPassword / SetIsReadOnly / SetIsSelectable → SetDelayed / SetPassword / SetReadOnly / SetSelectable;
  • IsFocus → IsFocused, SetFocus / SetBlur → FocusSelf / BlurSelf;
  • EnableInClass / ToggleInClass → EnableClass / ToggleClass;
  • AddStyleSheetsFromResource / RemoveStyleSheetsFromResource → AddStyleSheetFromResources / RemoveStyleSheetFromResources; AddStyleSheets(sheet) and RemoveStyleSheets(sheet) still compile, as the plural names now take several style sheets;
  • SetImageFromResource, SetSpriteFromResource, SetVectorImageFromResource, SetBackgroundImageFromResource → …FromResources;
  • MarkDirtyLayout → MarkDirtyLayoutSelf: IMGUIContainer.MarkDirtyLayout() hid the old extension, so the call returned void; the new name chains.
  • SetText of TextElement (Label, Button and others) → SetTextSelf: from Unity 6000.6 a string argument binds to Unity's own TextElement.SetText(ReadOnlySpan<char>), which returns void, so chains such as label.SetText(x).SetTooltip(y) failed to compile; the new name chains on every Unity version. SetText of Foldout, HelpBox and Toggle keeps its name.
• A bare null argument to SetBackgroundImage and, from Unity 6000.6, to SetTextSelf no longer compiles, because the new overloads fit it as well. Cast it, for example (string)null, or pass StyleKeyword.None to clear a background.
• Renamed the extension classes BaseFieldExtensionsSetLabel<Type> to BaseField<Type>Extensions (BaseFieldExtensionsSetLabelInt → BaseFieldIntExtensions) and ProgressBarExtensions to AbstractProgressBarExtensions. Extension-method calls are unaffected; only calls through the class name change.
• Renamed the extension class SerializePropertyExtensions to SerializedPropertyExtensions. Extension-method calls are unaffected; only calls through the class name change, such as SerializePropertyExtensions.GetFieldInfo(property).
• SetShowMixedValue no longer defaults its argument to true; pass the value explicitly.
• SetDirection, SetFill, SetInverted, SetPageSize and SetShowInputField now return the slider's own type (Slider, SliderInt) instead of BaseSlider<TValue>, so a chain keeps the slider's members. They accept BaseSlider<float> and BaseSlider<int>; the open BaseSlider<TValue> overloads are gone. The BaseSlider<int> overloads live in the new SliderIntExtensions class: extension-method calls are unaffected, but a call through SliderExtensions. on a SliderInt must switch to SliderIntExtensions..
• The parameterless constructors of SerializableType / SerializableType<T> are no longer public: create a wrapper with new SerializableType(type) or new SerializableType<T>(type) (null gives an empty one). SerializableMonoScript / SerializableMonoScript<T> have no public constructors: declare them as serialized fields and pick the script in the Inspector.
• SerializableType, SerializableMonoScript and their generic variants now compare by value; Equals and GetHashCode used to compare references. Wrappers that store the same type name are equal and share a hash code, so they work as Dictionary and HashSet keys, and List.Contains and IndexOf find an equal wrapper. == still compares references.
• [TypeSelector] on a [SerializeReference] field now offers only types assignable to every attribute type — the rule string and SerializableType fields already follow; it used to offer types matching any one of them. The same applies to baseTypes of SerializeReferenceEditorGUI.CreateField, CreateList and DrawFieldLayout. A list of alternatives such as typeof(Pistol), typeof(Rifle) now leaves the selector empty and triggers AFT0009: give the allowed classes a common interface or base class and pass that instead. AFT0005 now checks all attribute types together.
• The [TypeSelector] analyzer no longer resolves the attributes of fields without [TypeSelector] and skips assemblies that do not reference the package; it used to slow down every compilation of a large project.
• An IMGUI inspector no longer runs a full duplicate scan of a [SerializeReference] list for every element on every GUI event, only once per list per editor update or when the list size changes; a shared field no longer creates a SerializedObject on every repaint.
• Breakage detection keeps its baseline in memory and writes it to the session once, before a script reload, instead of parsing and rewriting all of it on every asset save, which cost milliseconds per thousand assets. Its start-up read decodes only the assets that hold a managed reference or a type name, instead of reading every asset in full.
• Deleting or moving an asset no longer drops the warm usage index of Project References, the delete guard and breakage detection. A delete removes the usages of that asset, a move into or out of an Excluded scan folder removes or adds them, and a move between scanned folders changes nothing. An import of more than 64 scanned assets drops the index once instead of patching it asset by asset.
• GetFieldInfo() and GetDeclaringInstance() cache the field lookup, and the check that decides whether a nested [SerializeReference] field has its own drawer is cached per field. An IMGUI inspector no longer creates arrays or attribute instances for every nested reference on every event, and creates fewer strings, so a large tree allocates less while the mouse moves.
• Fix all, Smart Fix, Migrate all, <None> and the summary's Undo in Project References no longer read a file again for every broken reference in it, and write it once. They check only once per file whether it is open or has unsaved changes, so a file with many broken references is repaired much faster.
• An empty [SerializeReference] field no longer parses the asset file on every repaint to check for a missing type: an unchanged file is read once, so empty fields in a large scene or prefab no longer slow the Inspector down.
• In the Inspector of a runtime object, the type picker no longer offers types from editor-only assemblies (UnityEditor, Editor asmdefs and Editor folders): a player cannot resolve them, so the value silently became null or a missing reference in a build. Fields of editor windows and other editor-only objects still offer every type.
• Paste, Paste Template, Link to Existing, a dropped script and Smart Fix follow the same rule in the Inspector of a runtime object: they no longer assign a type from an editor-only assembly or a generic type closed over one. The type picker of Asset References no longer offers such types for a runtime object either. Create New Script… leaves the field as it is and logs a warning when the new script is saved in an Editor folder.
• The unconstrained type picker (SerializableType without T, [TypeSelector] on a string, TypeField) reuses its type list between openings instead of rebuilding it from every loaded type each time.
• The type picker checks the field's base type first when it lists the loaded types, so a picker with a narrow base type, such as the + of a [SerializeReference] list of a specific interface, opens several times faster in a large project. An IMGUI type field resolves a stored type name once instead of on every repaint, which a missing type made slow.
• A type picker with a predicate, such as the picker of a SerializableMonoScript field, TypeField.Predicate or a [SerializeReference] field, no longer checks every loaded type again each time it opens: the types that pass everything but the predicate are listed once per set of base types and reused until an assembly loads, and only the predicate runs on each opening. In a project with about 55,000 loaded types, the picker of a SerializableMonoScript field opens in about 6 ms instead of about 85 ms, and the picker of a [SerializeReference] object field in about 90 ms instead of about 190 ms.
• TypeField(string label, Type defaultValue = null) is split into TypeField(string label) and TypeField(string label, Type defaultValue), and InspectorTypeField likewise. new TypeField(null) used to pick the property constructor and throw NullReferenceException; it no longer compiles, so name the argument: new TypeField(label: null). The bound constructors throw ArgumentNullException for a null property and ArgumentException for a property that is not a string. With binding-path set in UXML, the field logs a warning that it can be bound only from C#.
• Reading Type of SerializableType and SerializableMonoScript opens a Profiler marker only for the lookup of the type, not for a cached read, so reading it for many objects every frame no longer fills the Profiler with samples.
• EnumValues opens a Profiler marker only when it builds its entries on first access, not in GetValue, TryGetValue and Equals, so a lookup for many objects every frame no longer fills the Profiler with samples.
• SerializeReferenceIMGUIList.Draw now throws ArgumentNullException for a null property and ArgumentException for a property that is not a list of managed references, like SerializeReferenceEditorGUI.CreateList; it used to draw nothing. A null label now shows the property's display name; pass GUIContent.none to hide it.
• Renamed the currentAqn parameter of TypeSelectorWindow.Show to assemblyQualifiedName, like the other parameters that take an assembly-qualified name. Update calls that pass it by name: currentAqn: name becomes assemblyQualifiedName: name. Positional calls need no change.
• The generated this.Marker() code now declares its marker fields only under ENABLE_PROFILER, like the Marker() body that reads them: builds without the profiler no longer create every marker in a static constructor.
• ProfilerMarkerExtensionsForGenerator.Marker(this object) is now Marker<T>(this T, [CallerLineNumber] int line = -1): a struct call site the generator cannot mark is no longer boxed, so a Burst job still compiles. It takes the same parameters as the generated overload, so a type without a namespace, as in Unity's script template, gets its markers too. A this.Marker() call inside an expression tree no longer compiles (CS0854), and a method group now needs Func<int, AutoScope>.
• A generic class names nested type arguments the way C# writes them (Foo<List<Int32>>.Run (line), Foo<Outer<Int32>.Inner>.Run (line) instead of Foo<List`1>, Foo<Inner>). A generic struct gets one marker per call site for all its closed types, named Job<T>.Execute (line), because Burst cannot run the per-type label.
• The generated Marker() dispatches on the line with a switch, so its cost no longer grows with the number of call sites in a type.
• The generated Marker() takes a struct by in, so this.Marker() in a struct, such as a large job, no longer copies the whole instance on every call. The copy was made under Mono (the Editor, Mono players) and under IL2CPP when the call and the overload land in different C++ files.
• The scripting symbol that compiles out the package's own profiler markers is now ASPID_FASTTOOLS_UNITY_PROFILER_DISABLED, to match the other ASPID_FASTTOOLS_* symbols. The old ASPID_FAST_TOOLS_UNITY_PROFILER_DISABLED no longer works: rename it in Scripting Define Symbols.
• Aspid.FastTools.VisualElements.Math is no longer compiled as an empty assembly in projects without com.unity.mathematics.
• The animated dot background of the FastTools window and the settings page draws all its dots as one mesh instead of tessellating a path per dot on every frame, and pauses while Unity is in the background, so an idle open window no longer keeps the editor busy.
• The dot background repaints 20 times a second instead of 30. The new Animated background switch (FastTools window → Settings → Appearance, and Preferences → Aspid.FastTools → Appearance) hides the dots and stops their repaint timer, and stops the animation of the title and the logo on the Welcome tab.
• The hover gradient of a button in the FastTools windows runs its timer only while the gradient fades, and every gradient button shares one gradient texture instead of creating its own.
• The FastTools window (Welcome, Asset References, Project References and Settings) and its pages in Project Settings and Preferences follow the light editor skin: its canvas, cards, text, status colours and the type picker inside it take a light palette, Aspid-FastTools-Default-Light.uss; they used to stay dark on both skins. A theme still layers on top of either palette.
• The FastTools window keeps the view of each tab between visits: its scroll position, expanded rows, repair summaries and keyboard focus survive a switch to another tab and back. Asset References and Project References read the asset and the project again when you return.
• The cards of the FastTools window and of its pages in Project Settings and Preferences are opaque, so the dot background no longer shows through their text. The background and the title of the Welcome tab move only while their window is focused or under the pointer, and the Welcome logo pulses only under the pointer.
• The Settings tab marks where a setting is stored with a violet stripe for a project setting (committed, the same for the whole team) and a gray one for a per-user setting. Its legend and reset button say Project instead of Shared, the word Asset References uses for a shared managed reference, and Asset References marks such a reference with a coloured dot and a muted shared instead of a blue SHARED badge. The line above the legend is gone; the legend's tooltip says what the stripes mean. Drop-downs, sliders, object fields and the buttons of a row in Settings line up in one column at the right edge instead of taking half of each row. The description lines under the SerializeReference settings are gone: like every other setting, they are explained in the tooltip of their row. Excluded scan folders lists its folders in a framed box, which says No excluded folders when it is empty.
• Rescan in Asset References and Scan Project in Project References carry a refresh icon. Project References lists each file once, with its rid or, for several, their count (the tooltip lists them), dims the folder part of a path and adds Copy Path to the context menu of a row. Smart Fix and Migrate rows in both tabs name their target type with its namespace (Smart Fix → Game.Weapons.Pistol), and a missing type whose class name equals its fix's names the part of its namespace that differs (Legacy.Pistol). An orphaned reference is cleared from its card header, the way Change and Assign work on the other cards, and the Orphaned section is a plain heading instead of an amber box. Undo and Open Source Prefab are plain outlined buttons now, like the actions of the Settings tab; gradient bands stay for actions that span a card. The icon of an empty Asset References or Project References tab sits at the middle of the tab and no longer jumps when you switch tabs; its text follows below it. In a narrow window a group card of Project References cuts its type name and count with an ellipsis instead of breaking the name mid-word, Fix all keeps its width, and Smart Fix and Migrate rows in both tabs cut the type name in the middle, so the action and the class name stay readable.
• The shortcut hint of a tab in the window toolbar (⌥2) follows the tab title and hides when the tab is too narrow for both.
• The FastTools window takes the colours and corners of the documentation site: the accent green, amber, blue, red and violet are the site's, and cards and bands have 6 px corners instead of 8–10 px. Switches take the site's green everywhere; on the light skin an on switch fills its track with it under a white handle, inside a darker green outline, instead of a pale tint under a dark handle.
• The hint under the Project References header keeps only what needs attention, such as data that may be out of date or files that were not read, and Asset References drops its "N managed references mapped" line; how to act on the results moved to the tooltip of the header. Project References sorts its cards under Broken, Required, Prefab instance overrides and Renamed headings instead of a colour legend; a list of only broken or only renamed types has no heading. Required violations and prefab instance overrides get one card per file, headed by its path and entry count. Asset References shows an optional empty field as a one-line row in its place among the fields instead of a full card, and every object gets a folding heading named "GameObject › Component", or only "Component" when the GameObject has the same name, with the object's icon, a size above the sections inside them and neutral; their counts are in the tooltip. Every [TypeSelector] string, SerializableType and SerializableMonoScript field, required or not, is shown among the cards of its object in field order, with a field path written like theirs: a set one as a card with its type and Change, an empty required one as its amber card, and an empty optional one as a one-line row with Assign, as [SerializeReference] fields are. An object with such fields and no managed references gets its own heading too. The card of a known type shows the type's icon from the type picker. The Welcome tab describes the package as the site does and names every feature.
• [TypeSelector] on an array or List<T> field now applies to the collection itself (applyToCollection): its drawer draws the list and a picker for each element. PropertyField and EditorGUILayout.PropertyField on such a list now get the picker-backed + in UI Toolkit and IMGUI, and a PropertyField on a single element of it no longer shows the picker. SerializeReferenceIMGUIList.Draw and SerializeReferenceEditorGUI.CreateList add the constraints of a [TypeSelector] on the list field to baseTypes. Managed-reference lists drawn by the package now honor [NonReorderable].
• Renamed the value parameter of AddClass, RemoveClass, ToggleClass, AddStyleSheet, RemoveStyleSheet and their …If variants to className and styleSheet; a call that names the value: argument needs the new name.
• Style sheet methods such as AddStyleSheet and RemoveStyleSheet skip a null style sheet instead of throwing ArgumentNullException.
• RemoveChild and RemoveChildren skip null and elements that are not children of the element instead of throwing, so RemoveChildren no longer stops halfway.
• The child, class and style sheet extensions carry nullable annotations, so a project with nullable reference types enabled sees which arguments may be null.

Removed

• Removed SetExposedReferenceAndApply() from SerializedProperty extensions; call SetExposedReference() instead. Without an IExposedPropertyTable context, Unity's exposedReferenceValue setter already applies the write and records Undo, so the extra apply did nothing, and a variant without Undo cannot be built on top of it.
• Removed the editor-only SerializableMonoScript.Script, which returned the MonoScript asset; no public accessor for the asset remains. The type is still available through Type or the implicit conversion to Type.
• Removed AddMakeItem / RemoveMakeItem of ListView and TreeView, and AddMakeHeader / AddMakeFooter / AddMakeNoneElement of BaseListView with their Remove* pairs; the view keeps one factory, so call SetMakeItem, SetMakeHeader, SetMakeFooter or SetMakeNoneElement.
• Removed the Span<VisualElement> overloads of AddChildren, InsertChildren and their …If variants. A Span argument converts to the ReadOnlySpan overload, so existing calls compile unchanged.
• Removed the runtime Aspid.FastTools.StringExtensions.ToKebabCase and Aspid.FastTools.TypeExtensions.GetMembersInfosIncludingBaseClasses from the public API, without a replacement.

Fixed

• The Asset Store link and the logo of the Welcome tab open the package page on the Asset Store; they led to a page that does not exist.
• Unity 6000.6 no longer warns on import that seven of the package's stylesheet .meta files are below the supported serialized version.
• InsertChildren and InsertChildrenIf skip a null entry without moving the index: InsertChildren(0, a, null, b) puts b right after a; it used to leave a gap or throw ArgumentOutOfRangeException at the end of the parent.
• SetValue, SetValueAndApply and SetValueAndApplyWithoutUndo compile again with a byte, sbyte, short, ushort or char argument on Unity 6000.2 and later: the EntityId overload made the call ambiguous (CS0121). Each of these types now has its own overload that calls SetInt.
• The XML documentation of the UI Toolkit extensions now matches the behavior: SetValue(value, notify: true) raises the change event only when the element is in a panel and the value differs; SetPadding(8, 4), like SetMargin, SetBorderWidth, SetBorderColor and SetDistance, sets the top and the right side; a slider needs its range before SetValue; an inline lambda passed to AddValueChanged cannot be removed with RemoveValueChanged; on a ListView or TreeView, AddChild throws and InsertChild, RemoveChildAt and ClearChildren do nothing. Each method that exists only on newer Unity versions says Available in Unity 6000.x and newer.
• The documentation of SerializableType, SerializableMonoScript, EnumValues and [TypeSelector] strings now gives the right Managed Stripping Level for a class or enum that a field refers to only by its stored name: Medium and High strip it from a player, Minimal and Low keep it; it used to say Low. The Serializable Types page also lists the ways to keep such a class: [Preserve], link.xml, and [RequireImplementors] or [RequireDerived].
• The SHARED badge in Asset References now fits its text; it used to shrink to the width of its colour dot, so the text ran out of it and the dot covered the letter "H".
• Asset References shows unset required fields (the Required type is not set cards and REQUIRED badges) of an asset in an Excluded scan folder, as it already showed its missing types; the folder still keeps the asset out of Project References and the build / CI checks.
• Asset References no longer shows two states of an asset with unsaved changes at once, such as a card of a filled reference next to an amber card that says the same field is unset. It maps the saved file, so it now asks you to save the asset first and offers Save Asset.
• An unset required field gets the amber stripe on its left edge, as a missing type does, in both Inspectors: a [SerializeReference] field in UI Toolkit, and a [TypeSelector] string, SerializableType or SerializableMonoScript field in IMGUI and UI Toolkit. They showed only the notice; the IMGUI [SerializeReference] field already had the stripe.
• In both Inspectors, the label of an empty [SerializeReference] field, or of one with nothing to expand, and of a type name field with a warning stripe stays where it is when the field holds a value, in line with the labels around it, so it no longer jumps when you assign or clear the field. It sat a foldout arrow's width further left or 5 px further right; the stripe now hangs left of the label, in the spot of the foldout arrow. In UI Toolkit the icon of a notice under a field starts under its label, as in IMGUI; it was 3 px further left. The text of a Shared reference notice starts under the field label in both Inspectors; in IMGUI it was 3 px further right.
• In the IMGUI Inspector, a shared [SerializeReference] field keeps its type dropdown and the values of its child fields in the column of the fields around, as in UI Toolkit; the gap left for its stripe moved them 5 px right.
• Asset References no longer hangs the Editor on an asset whose [SerializeReference] objects point at each other: it drew a card for every path through the graph, and the number of paths grows exponentially. An object now shows its children once, under its first card that is not below a missing type; another field that points at it keeps its own card and field path, with children on another card in the footer. The window draws at most 1000 reference cards and says how many it left out; Project References repairs missing types without this limit. An asset with a list of thousands of objects also opens faster.
• GetDisplayName() and GetDisplayNameWithIndex() no longer append " (Script)" when [AddComponentMenu] is inherited from a base class or its path is empty or ends with /; such types get the nicified type name. The title now comes from the attribute declared on the type itself, and an [Obsolete] type no longer gets " (Deprecated)".
• A [TypeSelector(nameof(...))] member reference on a field inside a [Serializable] class or a list element now resolves on the instance that declares the field, as analyzers AFT0006–AFT0008 already check it; it used to be looked up on the inspected component or asset and showed a warning. The same applies to the picker of the Asset References window.
• A [TypeSelector(nameof(...))] member whose getter throws no longer breaks the field with exceptions in the Console: the field draws without that constraint and shows a warning with the exception message.
• AFT0007 no longer fails compilation on a Type? member under #nullable enable, and it now reports a property without a getter, which the Inspector cannot read. AFT0004 now also reports a UnityEngine.Object? field.
• AFT0005 no longer warns about a generic field or base type (IState<Enemy>, Base<int>, typeof(IFoo<int>)) that has a closed or open generic implementation, or about an implementation through out/in variance, which also no longer triggers AFT0003. Neither warns about a field of a type parameter (T in Slot<T>). An unbound typeof(Base<>) no longer triggers AFT0003 or AFT0005 when an open generic implementation such as Impl<T> : Base<T> can fill the field.
• [field: TypeSelector] and [field: SerializeReference, TypeSelector] on an auto-property are now checked by AFT0001–AFT0009, and AFT0003 now also covers SerializableType<T> and SerializableMonoScript<T> fields.
• AFT0008 now also reports a [TypeSelector] type name without an assembly, such as "Game.IWeapon", and names the assembly to add: the Inspector looks such a name up only in mscorlib, so the picker lost its constraint without a compile-time warning.
• A field type or typeof(...) argument the compiler cannot resolve (a missing asmdef reference, a class not written yet), or whose base class or interface it cannot resolve, no longer triggers AFT0001, AFT0003, AFT0005 or AFT0009 on top of the compiler error.
• AFT0005 now warns when a typeof(...) class does not fit the field type and no subclass of it does, such as [TypeSelector(typeof(Sword))] on an IShield field; the selector was empty without a warning. The AFT0005 message now also names the field type when it narrows the selection.
• AFT0001 no longer fails compilation on a field of a [Serializable] SerializableType subclass with a parameterless constructor, which the Inspector draws, and AFT0007 accepts a member of any ISerializableType type, which the Inspector reads.
• AFT0003–AFT0006 name types with their namespace and type arguments, so two closed types of one generic no longer read as 'Slot' and 'Slot'.
• Fix and Smart Fix of a missing type on a saved asset in a UI Toolkit inspector no longer log an exception; reference fields in other inspectors refresh right after the repair.
• A missing [SerializeReference] type stored without a namespace is no longer matched to an unrelated class whose [MovedFrom] names the same old class: the gate and Project References no longer list it as a pending migration, Migrate all no longer rewrites it to that class, and Smart Fix no longer ranks that class first.
• In Edit Mode the Shared reference notice, its number and the Make Unique Reference item now update right after an edit from an IMGUI inspector, Link to Existing or the reference graph window; they used to keep the state from before the edit until the selection changed.
• After you delete an element of an array that holds a [SerializeReference] list (a list of structs with a list inside), the list that moves into its place is no longer mistaken for a just-duplicated one; Auto de-alias used to split its intentional links, such as ones made with Link to Existing, into separate instances.
• An IMGUI [SerializeReference] field releases the copy of the object it opens for the context menu, the type picker and Fix; a cancelled menu or picker used to keep it until garbage collection, which grew native memory on a large asset. Make Unique Reference and a script dropped onto a field whose list element was removed meanwhile no longer throw NullReferenceException.
• A [SerializeReference] field now always opens to show the new value after a type pick, a dropped script, Paste, Paste Template or Link to Existing; it could stay closed, in the IMGUI Inspector after any of them and in the UI Toolkit Inspector after a drop, a template or a link.
• Selecting several objects whose [SerializeReference] field holds the same type now shows that type and its fields for editing together; the field used to show — and Different types selected unless the objects were exact copies.
• A type switch now keeps the same instances in [SerializeReference] fields inside structs, serializable classes, arrays and lists, and in private [SerializeReference] fields without [SerializeField] (including [field: SerializeReference] auto-properties), like it already did for other nested references; it used to put copies there, so fields that pointed at those instances lost the link. Make unique and the fix for a duplicated list element now copy such references with the rest of the reference, so two fields that shared an instance share its copy.
• A nested [SerializeReference] field now keeps a custom drawer registered for its declared type through an open generic type (typeof(Effect<>)), a base class or an interface, even without useForChildren, and a drawer registered for a base attribute class; the package used to draw its own header and type picker over them. In a nested list such a drawer draws each element in both IMGUI and UI Toolkit, and + keeps the type picker. A drawer of the stored type alone does not replace the type picker.
• A nested [SerializeReference] field without [TypeSelector] keeps its [Header], [Space] and [Tooltip] in an IMGUI Inspector, as in UI Toolkit; IMGUI drew it with no heading, gap or tooltip.
• Several [Header] or [Space] attributes on one nested [SerializeReference] field no longer make the UI Toolkit Inspector throw AmbiguousMatchException and leave the object's other fields unbuilt; they are drawn by order.
• A nested [SerializeReference] list with a custom attribute for each element (a PropertyAttribute with a drawer and applyToCollection off) keeps its picker-backed +; it used to fall back to Unity's plain list, whose + adds an element with no type choice. The attribute's drawer still draws each element.
• A custom drawer marked [SupportedOnRenderPipeline] for a render pipeline other than the current one, or any marked drawer in the Built-in pipeline, no longer takes the type picker away from a nested [SerializeReference] field. Unity does not use such a drawer, so the field was left with neither; the package now ignores it too.
• The per-user settings reset no longer lists the removed "Dropdown without [TypeSelector]" option in its tooltip and confirmation dialog.
• Keyboard focus in the Settings tab is easy to see: the focused row, a reset button, a folder entry of Excluded scan folders and its + get a strong border. The fill alone looked like the hover.
• Enter on the Build / CI gate row of the Settings tab no longer cycles Off, Warn and Fail. The Left and Right arrows step through the values without wrapping, and a step to Fail or Off asks for confirmation, because Fail breaks the team's builds and Off skips the check.
• ComponentTypeSelector now adds the components the new class requires with [RequireComponent], and refuses the switch with a Console warning when it would duplicate a [DisallowMultipleComponent] class, remove a class another component requires, or need a component that cannot be added. The required components are added before the new class, so its OnValidate finds them. It used to leave the object without the required components or with duplicates.
• ComponentTypeSelector no longer lists classes from Editor assemblies on a component of a runtime assembly: a build has no such class, so picking one left a missing script.
• ComponentTypeSelector refuses to change the class of a component inherited from a prefab (a prefab instance in a scene, a prefab variant) and shows a Console warning. Unity keeps no override for a changed script, so the new class was lost when the scene or variant was saved and reopened. Change the class in the source prefab; a component added to the instance can still be changed.
• Create New Script… on a [SerializeReference] field suggests NewInteractable for IInteractable (was Newnteractable) and NewEffect for IEffect<T> or a generic base class (was the invalid NewEffect`1, rejected on accept).
• Create New Script… on a [SerializeReference] field now writes a stub that compiles for an abstract class (it overrides every open abstract member and passes the arguments of a constructor that needs them), for ref, out and in parameters and ref returns, for generic methods with their constraints, for indexers, for a base type nested in a generic type, and for an internal base type in its own assembly (the stub is internal too); the file used to fail with compile errors that blocked Play Mode in the whole project. For a sealed class, a private or protected nested class, an internal class of another assembly, a class without an accessible constructor, or abstract members that the new script cannot override, a dialog explains why instead of writing the file.
• A saved template whose type does not resolve at the moment (another branch, a removed package, a class moved to another namespace or assembly) is now only hidden from Paste Template; opening the context menu used to delete it for good, in every copy of the project. Paste Template → Remove Missing (N)… deletes such templates on request, and overwriting one by name says that its type is missing.
• The name prompt of Save as Template… opens at the centre of the Editor window. It used to take the centre of the primary display's resolution and could open outside the Editor on a second monitor.
• Excluded scan folders accepts only Assets and folders under it, the only ones project scans walk; a folder under Packages/ or elsewhere was saved but excluded nothing.
• Changing Excluded scan folders now restarts the baseline of breakage detection: a type that only an excluded folder uses no longer raises a breakage notification, and a folder that is no longer excluded is covered again.
• Breakage detection now also reacts to changes of .asmdef, .asmref and .dll files, which move types between assemblies. A scan that waits for scripts to compile is no longer lost with the domain reload that ends the compile.
• Type picker search no longer matches the assembly part of a type name: short queries such as Key, Token, ver or null used to match every type. Search compares the label, the type name and the full name with the namespace and declaring types (Namespace.Outer.Name).
• Typing and Backspace in the type picker edit the query again after the Down arrow moves into the results; they used to be ignored until the search field was clicked.
• A type from an assembly that Unity loads while the picker collects the loaded types is no longer missing from the first picker after a domain reload.
• Type picker search lists the exact type name first, then names that start with the query, then names that contain it, and last the types found only through their namespace; Button no longer sits behind ButtonGroup. Equal matches keep the namespace order.
• Enter in the type picker's search field chooses the first result; it used to do nothing until the Down arrow moved into the list.
• Left arrow in the type picker's search results no longer takes the picker up a level; Esc then opened the list in the wrong folder.
• Type picker search results show the type name first and its namespace after it, dimmed, so a long namespace no longer pushes the name out of the row.
• The Recent section of the type picker no longer goes empty after picks in other fields: the project keeps the last 20 picks, and the section shows the newest ones that the open picker offers, as many as the Recent items setting allows. It used to keep only that many picks across all fields.
• On Unity 6000.6 and later, a search that shortens the type picker's list past the selected row no longer overflows the stack, which usually crashed the Editor: the list's refresh reported a selection change, and the picker answered it with another refresh.
• For a missing type the type picker no longer highlights <None>, so Enter right after opening does not erase the stored name.
• Picking the type a [SerializeReference] field already holds, or dropping its script, no longer creates a new instance: a reference shared with other fields stays shared, and the instance keeps every value. Under a multi-object selection only the objects that hold another type get a new instance.
• The type picker infers a generic argument that the field wraps in an array: for an IHolder<int[]> field, Box<T> : IHolder<T[]> is offered as Box<int>; it used to open the argument page.
• Generic argument pages of the type picker offer only types that meet constraints naming a type parameter (where T : IComparable<T>, where U : T) and keep the generic type assignable to the field; such a choice used to fail with an error after the click. A where T : unmanaged parameter no longer accepts a struct that holds references, from which the picker built a type C# would reject.
• The type picker no longer offers open generic types that no argument fits into the field, such as RefHandler<T> where T : class for an IHandler<int> field or Dictionary<,> for an IEnumerable<string> field; every choice on their argument page failed.
• For a field of a variant generic interface, such as IHandler<in T> or IProvider<out T>, where other arguments fit too, the type picker keeps the closed row inferred from the field, Handler<Animal>, and adds the open row Handler<T>: its argument page offers the other arguments that fit, such as object. It used to offer only the inferred row.
• Two nested types of the same name, such as PlayerController.State and EnemyController.State, no longer show as identical rows in the type picker: the outer class tells them apart, State (PlayerController). The row tooltip reads Namespace.Outer.Type, Assembly with generics spelled Box<T>, not the CLR name with the assembly version, and a type nested in a generic class lists only its own arguments (Inner, not Inner<T>).
• The type picker no longer offers the compiler's static-data structs (__StaticArrayInitTypeSize=12 in the <Global> group): types nested in compiler-generated types are left out.
• The key hint at the foot of the type picker fits the 400 pt window: Type to search and Esc Close used to be cut off. The arrow keys left the hint, and the favorite key reads Space ☆.
• A [TypeSelectorDisplay(Icon = "SwordIcon")] icon from Resources, named without a /, loads without the "Unable to load the icon" error in the Console. Such a name is looked up in Resources first, so a Resources texture now wins over a Unity icon of the same name.
• The type picker opened from the + of a [SerializeReference] list is placed by its real width of 400 pt instead of 350 pt, so it no longer runs 50 pt past the right edge of a narrow Inspector.
• The Missing type mark of a [SerializeReference] list element stays on that element after you delete, move or add elements and before you save; it used to follow the old index, so it moved to another element or disappeared. While the edits leave it unclear which element a slot holds, the slot shows no mark until the save. A reference inside an element of a list of plain classes or structs still follows that element's index until the save. A missing reference that you set to <None> or paste an empty reference over no longer shows Missing type until the save; Undo brings the mark back.
• Fix on a missing [SerializeReference] list element of an asset with unsaved list edits now applies the chosen class after Save and Continue; the save gave the element a new id, so the fix used to do nothing until you clicked it again.
• A SerializableType field or a [TypeSelector] string selected on several objects with different values now shows "—", and the type picker highlights no row; it used to show the type of the first object, as if all objects held it.
• In a UI Toolkit Inspector, choosing <None> now clears a SerializableMonoScript whose type is missing; the field used to keep showing <Missing …>.
• A SerializableType field or a [TypeSelector] string overridden on a prefab instance shows its label in bold and offers Apply to Prefab and Revert in its context menu; it could be reverted only from the component menu. A UI Toolkit Inspector still does not draw the blue override bar at its edge.
• The type picker of a SerializableType field, a [TypeSelector] string and TypeField offers generic classes for a closed generic base type, such as Handler<int> for IHandler<int>, as [SerializeReference] fields already did.
• TypeField.Types drops null entries; a click on the field used to throw NullReferenceException and open no picker.
• The type field (TypeField, and the SerializableType and [TypeSelector] string fields of a UI Toolkit Inspector) shows the full name of the selected type with its namespace and assembly as its tooltip, so two classes with the same name can be told apart; the open-script button has a tooltip too.
• A bound TypeField updates the SerializedObject of its property before it sends ChangeEvent<Type>: a change handler reads the picked type from that property, and edits the handler applies through that object no longer undo the pick.
• A TypeField bound to several objects no longer refreshes its display every 100 ms when no value changed, and stops checking once a target is destroyed.
• A PropertyField over a SerializableType, SerializableMonoScript or [TypeSelector] string now sends a ChangeEvent<string> with the old and the new type name when a type is picked or a script is dropped on the field. It used to send none; Unity 6000.4 only passed on the event of the caption text, such as Int32.
• With several objects selected, a SerializableMonoScript field whose objects differ shows — without a script button, not the first object's type (UI Toolkit, IMGUI). In UI Toolkit, picking that first type now writes it to the other objects; it used to write nothing.
• In an IMGUI Inspector, a SerializableType or [TypeSelector] string field whose selected objects differ no longer shows a script button that opens only the first object's script, and a disabled SerializableMonoScript or [SerializeReference] field no longer accepts a dragged script.
• The UI Toolkit drawer of SerializableType and [TypeSelector] strings no longer leaves a SerializedObject copy behind on every refresh, and no longer throws NullReferenceException when its property is gone, such as a removed list element.
• The IMGUI type pickers of SerializableType, SerializableMonoScript, [TypeSelector] strings and ComponentTypeSelector, and the → TypeName suggestion, no longer keep a copy of the object until garbage collection after a cancelled pick, which grew native memory on a large asset; the copy opens when a type is picked and is released at once. The UI Toolkit drawers of SerializableMonoScript, [TypeSelector] and ComponentTypeSelector no longer hold a copy of the object for as long as their Inspector is open. A component destroyed between the pick and the ComponentTypeSelector swap no longer throws, and the UI Toolkit drawer of SerializableType and [TypeSelector] strings keeps refreshing when its Inspector has already disposed its SerializedObject.
• + of a [TypeSelector] [SerializeReference] list nested in an element of another array (a list of structs, a list inside a list element) now appends to that list; it used to throw InvalidOperationException and add nothing.
• + of an array whose elements contain a [TypeSelector] [SerializeReference] field (such as WeaponSlot[]) now adds a regular element; once the array had an element, it used to open that field's type picker and throw.
• + of a managed-reference list with several objects selected now appends an independent instance to every object in one Undo group. In IMGUI it used to change only the first object; in UI Toolkit the new element shared its instance with the previous one.
• The EnumValues Inspector no longer rewrites keys while drawing: a row whose key the enum cannot parse (after switching EnumValues<TValue> to another enum, or renaming or deleting a member) shows its key as, for example, <Missing Frozen> and keeps it until you pick a member. It used to get the enum's first member, so switching the type back did not bring the rows back. A row added to an empty table now shows <None> and is skipped with an error until you pick a member; it used to get the first member automatically.
• The EnumValues Inspector no longer writes to the asset while drawing: it used to add an Undo entry and mark the asset changed when a row's copy of the enum type differed from the table's. Rows no longer store that copy, so moving an enum no longer shows up in every row of a diff or merge; the old _enumType line of a row disappears from an existing asset the next time it is saved.
• Populate Missing Enum Members now works when the value is an array or a List<T>; it used to throw and leave a half-created row. For an enum with aliases (Default = Medium) it adds each value once and is disabled once every value has a row; it used to add a duplicate on every click.
• Populate Missing Enum Members is disabled while several objects are selected, and it skips [Obsolete] enum members. With several objects selected it used to set one array size on all of them: an object with more rows lost the extra ones, and the rest were overwritten with the rows of the first.
• An EnumValues row of a [Flags] enum based on long or ulong, or on uint with a member in bit 31, gets a flags dropdown that keeps every bit; for a 64-bit enum the IMGUI Inspector used to throw on every repaint, and the UI Toolkit one showed a wrong mask and stored a different key.
• An EnumValues row whose key is an [Obsolete] enum member, or for a [Flags] enum includes one, now shows the key by name. The dropdown used to be empty, or read None or Everything for flags.
• In the UI Toolkit Inspector the key dropdown of an EnumValues row now follows Undo, Revert and Paste, and the table header shows the label passed to PropertyField instead of always the field name.
• The EnumValues drawer no longer throws NullReferenceException when Unity finds no field for the property.
• The type picker of EnumValues<TValue> no longer offers the abstract System.Enum. Picking it filled the field, so the required check stayed quiet, but the table could never match a row and always returned Default Value.
• EnumValues initializes its rows safely when the first access comes from several threads: on a CPU with weak memory ordering another thread could see the table as initialized before its rows and return Default Value for a row that exists.
• The EnumValues enumerator returns default from Current after MoveNext returns false, as its documentation says. It used to keep the last row.
• Choosing Everything, or ticking every flag, in the key dropdown of an EnumValues row of a [Flags] enum now stores the enum's defined flags, for example Left, Right. It used to store -1, and GetValue never found that row.
• In the IMGUI Inspector, an EnumValues row whose value is a Rect, RectInt or Bounds is now as tall as that field and no longer overlaps the next row, and the notice of the enum type field (Required type is not set, Missing type) no longer draws over the table below it.
• Undo after Fix of a missing type in an open scene or Prefab Mode brings back the missing reference with its stored data; it used to leave the field empty, and the next save wrote rid: -2. The replaced entry is now dropped when the scene or prefab is saved (Prefab Mode Auto Save saves right after the Fix), so Unity's missing-types notice stays until then; that save also clears the object's Undo history, so the repair can no longer be undone.
• Fix of a missing type in an open scene or Prefab Mode now repairs every field that shares the missing reference, and the fields keep sharing one instance; the other fields used to show <None> without Fix until the save, which wrote them empty. The class picker and the → suggestion offer only classes that fit every such field.
• Fix of a missing type in a scene or Prefab Mode carries more of the stored data over to the new class: floats that Unity writes with an exponent (9.99e-05) were lost, text with non-ASCII characters, tabs or line breaks used to keep its quotes and escape codes, long text lost the part Unity wraps onto the next lines, Infinity and NaN became 0, and text such as 1.5 became 1.500000. A value the new class cannot take no longer drops the other fields.
• The package's editor assembly now compiles on Unity 6000.5, where Object.GetInstanceID() became an error (CS0619); it used to leave the project in Safe Mode with every editor tool of the package broken.
• Aspid.FastTools.VisualElements.Math now compiles on Unity 6000.5 and later in a project without com.unity.mathematics. Unity.Mathematics ships in the engine there, but SetValue and AddValueChanged for float2, int3 and the other types stayed missing until the package was installed.
• Fields drawn in a regular Inspector, UI Toolkit or IMGUI, now follow the light editor skin: the EnumValues drawer takes its backgrounds from Unity's theme, reference notices and the missing-type caption of [SerializeReference] fields use Unity's warning colour, and the warning, info and folder icons switch to their light-skin variants.
• The type picker is readable on the light editor skin: opened from an Inspector field it takes a light palette, with light-skin folder, Favorites and Recent icons; it used to draw the dark palette's light text on Unity's light popup background.
• Help boxes in the FastTools windows read at 4.5:1 or more on every status colour: their title and message take the strongest text shade. On the light skin, help boxes take the light-skin icons, and status-coloured links and actions are darker. In the type picker dropdown, the counts, arrows, hints and error text are brighter on the dark skin and darker on the light one; on the light skin the Favorites star is darker too. In the Inspector on the light skin, the Shared reference notice darkens its text and Make unique, while the dot and stripe keep their colour. On the light skin, hovered notice links turn darker instead of paler. The hovered remove button in Excluded Folders reads better on both skins.
• The Welcome tab of the FastTools window takes the theme too; it kept the built-in palette.
• The version, the GitHub link and the logo of the FastTools window show the link cursor on hover, and the version and the keys hint in the footer use a higher-contrast text tone that is easier to read.
• The keys hint in the footer of the FastTools window no longer runs over the version in a narrow docked window: it gets the space between the version and the link and ends with an ellipsis when it does not fit.
• The keys hint in the footer of the FastTools window names the Left and Right arrows (←→ adjust) on the Settings tab, where they step the Build / CI gate and the sliders. The other tabs, where these arrows do nothing, keep ↑↓ navigate ⏎ activate esc dismiss.
• When the package sits in Assets outside Assets/Aspid/FastTools (an Asset Store import moved to another folder), the footer shows its version instead of v? and the Welcome tab lists its samples; the package folder is now found by the GUID of its package.json.
• Import of a sample on the Welcome tab no longer fails silently when the project holds a copy of that sample from an older package version: it asks to replace the old copy and imports the current one. It used to show "Failed to import" and copy nothing.
• The Welcome window opens once after an update of a package installed into Assets (Asset Store, .unitypackage); the "already shown" flag followed a version that was always unknown there, so it never changed.
• Importing the package into Assets (Asset Store, .unitypackage) no longer logs five "Asset reference to GUID … was moved" warnings for the Welcome window: it takes its style sheet and logo from Resources instead of links by asset path.
• The Welcome window no longer promises "string ID tooling", which the package does not have; its text names the main features.
• A theme now recolours the cards, panels, status tints, scrollbars, dots background and switches of the Aspid windows: their colours moved into --aspid-colors-* tokens, and switches read the optional --aspid-colors-switch-* tokens.
• The borders of the dropdowns and the slider value box, and the slider track, in the Settings tab and in its pages in Project Settings and Preferences reach 3:1 contrast on the dark and the light skin; they were barely visible. The new --aspid-colors-control-border token sets their colour, so a theme can change it.
• On Unity 6000.0–6000.2 the [SerializeReference] field, the picker and the Project References and Asset References windows are styled again: two stylesheets used a color syntax these versions cannot parse, so each was dropped whole and the import logged an error.
• Buttons and foldouts inside a [SerializeReference] field drawn with UI Toolkit keep their own look: a button of a custom drawer or a nested list's + / − is no longer shrunk to 18×18 with a folder icon, and a nested foldout no longer takes the field header's layout.
• With several objects selected whose [SerializeReference] fields hold different types, the UI Toolkit field now tints its "—" like Unity's own mixed-value fields; it used to show it in the plain text colour.
• Fix, Fix all and the summary's Undo no longer rewrite the type of a healthy managed reference when a [SerializeReference] list inside another reference points at the broken one (a parent with a list of children). The Inspector reads the right stored type and fields of such references, and the Project References graph no longer shows phantom nodes whose Clear deleted healthy entries.
• When fields of different types share a missing reference, the class picker and Smart Fix in Asset References offer only classes that fit all of them, and so do those of a Project References group whose references all have the same field types; a [MovedFrom] target counts as a pending migration only if it fits all of them. They used to check one of the fields, so the others became empty after the rewrite.
• The missing-list guard now snapshots a missing list element that another reference's list also points at, and restores it into the object's own list instead of a same-named list nested in another field.
• The missing-list guard no longer brings back a missing list element after you delete it or set it to <None> and save; when you delete another element, it restores the missing ones at their new indexes. If the deleted element sat among other missing or <None> elements, the saved file doesn't say which one it was: the guard keeps the <None> elements and the first missing ones and leaves the last missing one out. Loaded scenes and prefabs saved from Prefab Mode are no longer guarded: the guard doesn't rewrite their files and doesn't restore their missing list elements.
• A dropped script, Paste Template, Link to Existing and Create New Script… on a missing list element now tell the missing-list guard that the element was replaced, as the type picker and Paste do; after such a replace and the deletion of another element, the save could lose a different missing element of the same list.
• A list element restored by the missing-list guard keeps its original reference id when it is free, otherwise gets a random one. It used to take the next id after the file's maximum, which an override in a variant, nested prefab or scene often already used: that override lost its type and shared data with the restored element.
• The missing-list guard finds the slot of a missing element by the reference ids of the other elements, so the element survives a reorder, a delete plus an add, an insert or a move in the same save; the guard used to look at the old index and silently drop it. A missing element that two slots share comes back in both of them, and a <None> pick on one of them no longer drops the other.
• The missing-list guard keeps a <None> pick on a missing element after a script reload and after an Undo of another edit; only a save that writes the file uses it up, and a change to the file outside the editor, such as a revert in version control, cancels it. Its Console message names the restored elements and warns about the missing elements it found no slot for, with their index and rid. The guard reads and writes the file once per save and skips files without managed references, so saving a list of thousands of elements no longer freezes the Editor, and an edit made right after a save is no longer lost when the guard rewrites the file.
• Objects with a negative fileID (prefab components, sub-assets) are now read as separate documents: their missing references reach the scans and the build gate, their unset required fields reach the scans, and Fix, Clear and orphan removal no longer edit or delete entries of the neighbouring object.
• The SerializeReference scans now read Animator Controllers (.controller) and Timelines (.playable), so missing types in their state machine behaviours, tracks and clips reach Project References, the build gate and breakage detection; these files used to be skipped.
• A [SerializeReference] type whose class, namespace or assembly name has characters outside ASCII (Cyrillic, CJK) is no longer reported as missing by the scans and the build gate, and the delete guard now finds its usages. Unity writes such a name as \uXXXX escapes in double quotes, which are now decoded; the same applies to the names stored by SerializableType and SerializableMonoScript.
• A [SerializeReference] field of a prefab variant, nested prefab or scene instance whose type is missing now shows Missing type instead of an empty <None>; the tooltip names the source prefab to repair, or says the type is stored in a prefab override. A required field with such a missing type no longer counts as unset in -srGateRequired and the References windows.
• A new element of a [SerializeReference] list that is empty in the saved file no longer shows the Missing type of an element of the next list until the asset is saved.
• The breakage notification no longer waits for Project References to scan the project in the session: a background read of the asset files at session start sets its baseline, and assets saved later update it, so a type first assigned during the session is covered too. A type that breaks before that read completes is not reported.
• Deleting a script that declares only components or ScriptableObjects no longer scans every asset of the project; for other scripts a progress bar appears when the check takes long, and cancelling it cancels the delete.
• The delete guard now warns for every type declared in a script, including a file with no class named after it (Pistol and Rifle in Weapons.cs) and nested types (Outer.Inner); it used to check only the class named after the file. A partial type counts only when no remaining script declares another part of it.
• The delete guard no longer slows down when you delete many scripts or a large folder: assets without managed references are skipped before any class name is searched, and of the several scripts or folders in one delete only the first sweeps the whole project, while the others re-read just the assets that hold managed references. Cancelling the progress bar cancels the delete of that script or folder and of every later one that needs the check.
• One answer of the delete guard can cover the whole delete. When the Project window selection holds more scripts or folders, its dialog gets a third button, Delete All Anyway, and Cancel keeps every other script or folder of that delete that is still used, without asking again; Delete Anyway still answers for one script and asks again for the next. The answer ends with the delete, so the next delete asks again. The dialog of a single script or folder is unchanged, and a delete from code that selects nothing shows the plain dialog first and the third button from the second dialog on.
• The SerializeReference scans skip binary assets and Git LFS pointers after reading their first bytes, instead of decoding every file as text on each build. The build gate and the CI check warn when files went unchecked (any binary file outside Force Text, a binary prefab, scene or ScriptableObject in Force Text, a pointer that was never pulled), and the CI report counts and lists them; before, such a project passed with 0 violations.
• The build gate and the CI check now warn about a file whose managed references are stored in an older format (references: version: 1, an asset last saved before Unity 2021.2) or in a format they do not know, and the CI report lists it as UnsupportedReferencesVersion; such a file used to pass as clean. The header line of the report is now # Not scanned: N, without (not text YAML).
• The project scan of managed references (the index behind Find Usages, the delete guard and breakage detection) no longer builds a field path for every pointer of a file: a file with a list of 8000 references took about 9 seconds to read, now about 0.2 seconds.
• A [TypeSelector(Required = true)] array or list in a scene is no longer reported as unset by -srGateRequired and Project References; scenes skip collections, as documented.
• Project References no longer shows "Project clean" or "Nothing left to repair" while required fields are unchecked (before the first Scan Project, after a clear in Prefab Mode or an open scene, or with gate severity Off); it says why they were not checked and to Rescan. Clearing references on disk now re-checks the edited files and the variants and prefabs nesting an edited prefab, so their required violations stay listed and the header warns about them.
• Project References no longer says "Project clean" when Scan Project could not read some files: binary files and Git LFS pointers are counted in the window and listed in the Console, and Asset References shows "Not scanned" instead of "No managed references" for such an asset. It no longer says there are no type names when only the index was warm (after Unity Search or another tool read it); it asks to Rescan. The hint about Fix all appears only when a broken group is listed, and a hint beside type names or required violations says they are as of the last scan.
• A file that cannot be opened (another program has it locked, no read permission, removed during the scan) is no longer called binary by the SerializeReference scans: the build gate and the CI check warn that it could not be opened and to close the program that holds it, instead of advising Force Text; the CI report lists it as Unreadable, -srGateStrict counts it like the other unchecked files, Asset References names the real cause, and Project References counts the file and points to the Console. The scans also read a text asset that another program has open for writing (Windows refused it before) and list a file that turns unreadable between the format check and the read, instead of passing it as clean.
• The summary after Fix all and Clear in Project References now shows how many entries could not be rewritten (a read-only or locked file, an entry that changed since the scan) and points to the Console; a fix that changed nothing says so instead of "Rewrote 0".
• The required-field sweep of -srGateRequired and Scan Project now unloads the prefabs and assets it loaded, so its memory no longer grows with the size of the project.
• Project References no longer loads every affected prefab again each time you switch to its tab, which froze the window when a broken class is stored in hundreds of prefabs. The field types of a group are read once and kept until a prefab or asset is imported or you Rescan, the prefabs this loads are released in batches, and a required-violation row takes its component name from the scan instead of loading its file again. A group lists its first 200 entries, and Show more adds the next 200.
• Scan Project shows a progress bar for the required-field sweep, and both sweeps can be cancelled. A cancelled scan keeps the earlier results and summaries.
• Under Warn the CI check logs its violations as warnings instead of errors, so a wrapper that looks for errors in the log no longer takes a run with exit code 0 for a failure.
• The build and CI logs list at most 50 violations, count the rest, and carry no stack trace; the CI report still lists them all. A CI run whose report folder does not exist now logs the violations before it fails.
• Clearing references and repairing type names in Project References no longer ask Unity for the dependencies of every prefab in the project on each action to find the variants and prefabs nesting the edited one; the map is built once per Scan Project.
• Assign Required for a SerializableMonoScript field in Asset References now offers only types with a script asset, as the Inspector does; it used to accept nested, generic and DLL types and drop the script reference.
• An unset required SerializableType, SerializableType<T> or SerializableMonoScript field of a prefab or ScriptableObject is now reported by -srGateRequired, the CI report and the References windows under its own path (weaponType), as in a scene; the path used to end in ._assemblyQualifiedName.
• In the editor, SerializableMonoScript now takes the type from its script when the stored name no longer resolves, so an object loaded in Play Mode after a class rename (an additional scene, Resources.Load, entering Play Mode without domain and scene reload) no longer gets null before its asset is saved again.
• SerializableType and SerializableMonoScript now cache a failed lookup as well: reading .Type of a missing type no longer calls Type.GetType every time, and the cache resets when the stored name changes.
• In the editor, serializing a SerializableMonoScript off the main thread no longer calls MonoScript.GetClass, which works only on the main thread; the stored name re-syncs on the next main-thread save.
• Fixing a missing [SerializeReference] type (retype, clear, remove an orphan, restore a list element) now checks the asset out in version control first, as Unity's own saves do. A read-only asset is left untouched with a clear error instead of an access exception, the edit replaces the file in one step so a failed write no longer leaves it truncated, and a UTF-8 byte-order mark is kept.
• The repairs that edit asset files directly (missing [SerializeReference] types, missing type names, restored list elements) now check the edited text before they replace the file. When the edit would lose or cut into another object or managed reference, or the file changed on disk after the repair read it, the file is left untouched with an error.
• A repair that edits an asset file no longer replaces bytes that are not valid UTF-8 with U+FFFD across the whole file; such a file is left untouched with an error.
• Clearing a missing [SerializeReference] reference no longer sets a field of your own named rid to -2 when it holds the id of the cleared reference; only the fields and list elements that point at the reference are nulled.
• The SerializeReference scans and repairs read and write ids such as rid: -2 and negative fileIDs the same way in every system locale. On the CoreCLR runtime, a Swedish, Finnish or Norwegian locale wrote −2 with a Unicode minus sign that Unity cannot read, and an Arabic, Hebrew or Persian locale failed to read negative ids.
• The shared SerializeReference settings (Build / CI gate, Excluded scan folders, Auto de-alias duplicated list elements) now follow ProjectSettings/SerializeReferenceSharedSettings.asset while the Editor is open. The settings page, a change of one setting (including adding or removing an excluded folder), Scan Project and the build gate re-read the file, so values pulled from the repository are no longer kept stale or overwritten by the next change. The file is also checked out in version control before it is written; if it stays read-only, the setting keeps its value and an error says why, instead of reverting after a restart.
• Repairing a missing type no longer silently discards unsaved changes of the asset being repaired. Fix and Smart Fix in the Inspector and repairs and clears in Asset References offer to save such an asset first; Fix all, Clear and Undo in Project References skip it or clear it in memory. Fix in the Inspector no longer rewrites a prefab asset that is open in Prefab Mode.
• Changing the type of a healthy reference or filling an empty or required field in Asset References (Change ▼, Assign ▼, Assign Required ▼) no longer writes into a prefab that is open in Prefab Mode; a dialog asks you to close it first. The change used to go into the file, and the next save of the stage overwrote it.
• The summaries in Project References and their Undo now survive a switch to another tab of the window, including the jump to Asset References from an entry row; they used to disappear with the tab. Rescan, closing the window or a domain reload still clears them.
• The FastTools window reopens on the tab you left after a script recompile or entering Play Mode; it used to return to Welcome.
• Tools → Aspid 🐍 → FastTools → Asset References with nothing selected, or with a selection it cannot map (a scene object that is not a prefab instance, a folder, a texture), keeps the asset the tab already shows; it used to replace it with an empty target.
• this.Marker() inside a private or protected nested type no longer breaks compilation with CS0122. The generated overload cannot see such a type, so the generator now skips it: the call compiles, opens no marker, and AFT0010 reports it — make the type internal or public to profile it.
• this.Marker() in a type nested in a generic type (Outer<T>.Inner) now compiles; the generated overload used to miss the outer type parameters (CS0246).
• this.Marker() in an indexer accessor or a static constructor now compiles; the generated field names were invalid. The markers are named Type.Indexer (line) and Type.StaticCtor (line).
• this.Marker() in an event accessor is now named after the event, like a property accessor: Type.Changed (line) instead of Type.add_Changed (line) / Type.remove_Changed (line), including explicit interface implementations.
• this.Marker() no longer breaks compilation in an auto-property initializer, a static class or a default interface method, in a namespace or type parameter named with a keyword (Game.@event, Foo<@event>), or when type names differ only in case or flatten to the same name (Foo/foo, Foo<T>/Foo_1, Outer.Inner/Outer_Inner); some of these made every marker of the assembly disappear.
• this.Marker() in an [Obsolete] type, a type nested in one or a generic type constrained to one no longer raises CS0618 in the generated code, and in an [Obsolete(..., true)] type no longer breaks compilation with CS0619.
• Foo, Foo<T> and Foo<T1, T2> in one namespace no longer share one generated class in which only the first type got markers; the package's own EnumValues<TEnum, TValue> markers now open.
• A this.Marker() call split over several lines or under a #line directive now opens its own marker; the generator used a different line than [CallerLineNumber].
• A generic struct marked [BurstCompile] no longer fails the Burst build (BC1025/BC1360).
• A type deriving from a type of another assembly that shares its namespace through InternalsVisibleTo now gets markers of its own; its calls used to bind to the base type's overload and open nothing.
• WithName($"Br{{ace}}") gives Br{ace}, WithName text with U+2028, U+2029 or U+0085 compiles, and a user's own WithName extension no longer renames the marker.
• WithName now reads a const, nameof(...) and a concatenation or interpolation of constants; such a name used to leave the member name without a warning.
• Persistent() no longer leaks the SerializedObject it creates when the property path no longer exists on the targets; it disposes that object before returning null.
• AddChildren, InsertChildren and their …If variants with an IEnumerable no longer throw InvalidOperationException ("Collection was modified") when given Children() of another element: target.AddChildren(source.Children()) moves every child.
• TryGetByEnum returns false for a USS number that is not a member of the enum (--preview-theme: 7;) and for a comma-separated list on an enum without [Flags], so the element keeps its default instead of an undefined value. A [Flags] enum accepts names only.
• Types sample: the Enemy Type picker no longer offers the abstract Enemy, which spawned empty capsules and an error per enemy; the rename step of its tutorial now uses the IDE's Rename refactoring, so ArmoredGrunt keeps compiling.
• Types sample: Brute no longer sinks halfway into the platform; its height now follows its scale.
• SerializeReferences sample: no more CS0414 warning on import, and deleting the Training Dummy in Play Mode no longer throws MissingReferenceException on every shot.
• EditorTools sample: the Ability Catalog window follows assets created or deleted in the Project window, and Create selects the new asset even while a search is active.
• EditorTools sample: the Ability Catalog window keeps its search text in the saved window layout, so it survives an Editor restart.
• EditorTools sample: the Ability Catalog window disposes the SerializedObject of the ability it showed when you select another one or close the window; it used to keep each until garbage collection.
• EnumValues and ProfilerMarkers samples no longer break compilation of a project without the built-in Physics module; their scripts are skipped there, and the sample descriptions say they need it.
• EnumValues sample: the Walker no longer puts [InspectorName] on fields, where Unity ignores it (it reads the attribute only on enum values); its Inspector labels are Step Interval and Footprint Lifetime, and Log Tables prints the same label.
• Types and SerializeReferences samples: the descriptions say that the colliders of their scenes need the built-in Physics module.
• The package's internal editor elements (AspidBox, AspidLabel and ten more) no longer show in the UI Builder Library of your project: they are made for the FastTools windows and look unstyled in your UXML.
• The tab icon of the FastTools window is a 64×64 texture with mipmaps (7 KB) instead of a 1022×1011 one without them (583 KB): the package is smaller and the icon edges stay smooth at 16 pt.
• Persistent() keeps the context of the source SerializedObject, so an ExposedReference read or written through the copy resolves in the same table (for example a PlayableDirector) instead of the default value in the asset.
• Link to Existing in the [SerializeReference] context menu now offers only instances the field's type picker accepts under its [TypeSelector] base types, including member-referenced ones; it used to offer any instance assignable to the declared field type.
• A generic class picked in the [SerializeReference] type picker now fits every [TypeSelector] type: a closed type outside the attribute, such as Modifier<Int32> under [TypeSelector(typeof(IModifier<float>))], shows an error. It used to be stored although the attribute rejects it.
• The type picker infers generic arguments from every [TypeSelector] type: when they pin every argument, as [TypeSelector(typeof(IModifier<float>))] pins Modifier<T> to Modifier<Single>, picking the generic closes it at once. It used to look only at the field type of a [SerializeReference] field, and at the first [TypeSelector] type elsewhere.
• On a generic argument page of the [SerializeReference] type picker, a nested generic is checked like any other argument: a class without [Serializable] and a .NET generic struct such as Nullable<T> or KeyValuePair<,>, whose values Unity silently drops, are no longer offered. Your own [Serializable] generic struct can now be a nested argument, as in Container<Optional<int>>.
• The [SerializeReference] type picker no longer offers or accepts, as a generic argument, a .NET type that carries [Serializable] but whose values Unity silently drops: DateTime, TimeSpan, Guid, Decimal, Dictionary<,>, HashSet<T>, Queue<T>, Stack<T>, LinkedList<T>, Tuple<…>, object and IntPtr. Among the .NET types Unity serializes only primitives, string, enums, T[] and List<T>, so those still fit; a multidimensional or jagged array, a List<List<T>> and a collection of an element Unity drops are rejected as well. Your own [Serializable] types are not affected.
• SerializeReferenceEditorGUI.CreateField and DrawFieldLayout now add the [TypeSelector] constraints of the field to baseTypes, as CreateList already did. The type picker used to offer every type that fits the declared field type, where PropertyField offers only the selected ones. CreateField reads the constraint once, when the field is created.
• Find Usages in the [SerializeReference] context menu now lists usages of the exact type in the field (namespace and assembly included); it used to match every stored class name containing its name, such as PistolMk2 or a Pistol from another namespace. A typed sr: query still matches class names by substring.
• Find Usages of … and Link to Existing in the [SerializeReference] context menu name a generic type as the type picker does, Modifier<Single> or its [TypeSelectorDisplay] name; they used to show Modifier`1. A / in a display name no longer opens a submenu.
• In the default UI Toolkit Inspector, + of an empty [TypeSelector] [SerializeReference] list now opens the type picker; it used to append a <None> entry, and the picker appeared only once the list had an element.
• The breakage notification and the breakage detection setting point at Project References; they still named its old tab, Repair.
• An EnumValues table in an array or a list is titled Element 0, Element 1 and so on, as other array elements are; it used to show the full name of its enum type, since Unity names an element after its first string field. A long title ends in an ellipsis inside the card instead of running past its border, in both the UI Toolkit and the IMGUI Inspector.