feat: update for Morpeh 2024.1.1 compatibility

Add new system base classes (QueryFixedSystem, QueryLateSystem,
QueryCleanupSystem), ForFirst query overloads, Extend<T> support,
and CompiledQuery.Count().

Fix FilterBuilder struct compatibility (Also callback), reflection
invocation (Build), empty filter crash, validation bug, compile
errors without MORPEH_BURST, and rename typo in EventListenerExtensions.

Cache MakeGenericMethod results in QueryBuilder.Build() for better
performance.

Author: Andrey Cherkashin

CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+
+All notable changes to Morpeh.Queries will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+---
+
+## [2024.1.1] — 2026-02-23
+
+### Added
+
+- **`QueryFixedSystem`** — base class combining `QuerySystem` + `IFixedSystem` for FixedUpdate systems.
+- **`QueryLateSystem`** — base class combining `QuerySystem` + `ILateSystem` for LateUpdate systems.
+- **`QueryCleanupSystem`** — base class combining `QuerySystem` + `ICleanupSystem` for cleanup systems.
+- **`CompiledQuery.Count()`** — returns the number of matching entities via `filter.GetLengthSlow()`.
+- **`QueryBuilder.Extend<T>()`** — support for `IFilterExtension` custom filter extensions.
+- **`ForFirst` overloads** in `QueryBuilderExtensions` — execute a lambda for the *first* matching entity only. Available in all variants:
+  - `ForFirst(Action<Entity>)` — entity only
+  - `ForFirst<T1>(Action<Entity, T1>)` / `ForFirst<T1>(Action<T1>)` — 1 component
+  - `ForFirst<T1,T2>(...)` — 2 components
+  - `ForFirst<T1,T2,T3>(...)` — 3 components
+  - `ForFirst<T1,T2,T3,T4>(...)` — 4 components
+
+### Fixed
+
+- **Morpeh 2024.1.1 compatibility — `QueryBuilder.Build()` reflection**: `FilterBuilder.With<T>()` and `Without<T>()` are now zero-parameter instance methods. Fixed invocation to pass `null` instead of `new object[] { filterBuilder }`, preventing `TargetParameterCountException` at runtime.
+- **Morpeh 2024.1.1 compatibility — `CompiledQuery` empty filter crash**: In Morpeh 2024.1.1 an empty `Filter` matches *all* archetypes, making direct `world.entities[]` iteration unnecessary and unsafe (null archetype slots). Fixed by always using the `Filter` enumerator regardless of whether include/exclude types are present.
+- **Morpeh 2024.1.1 compatibility — `QueryBuilderExtensions.Also()`**: `FilterBuilder` changed from a class to a `struct` in Morpeh 2024.1.1. The previous `Action<FilterBuilder>` signature silently discarded all modifications. Fixed by changing to `Func<FilterBuilder, FilterBuilder>`.
+- **`QueryHelper.ValidateRequest`**: `hasProblems` was declared but never set to `true` inside error branches, meaning validation exceptions were never thrown even when components were missing from the filter. Fixed.
+- **`QuerySystem` compile error without `MORPEH_BURST`**: `IsUpdatedEveryFrame`, `AddExecutor()`, `CreateQuery()`, and `m_executors` were incorrectly placed inside `#if MORPEH_BURST`, causing compile errors in non-Burst projects. Moved outside the conditional block.
+- **`EventListenerExtensions` method name**: `CompiledCompiledEventListener` (duplicate word) renamed to `ForEach`.
+
+### Improved
+
+- **`QueryBuilder.Build()` performance**: `MakeGenericMethod` results are now cached in static `Dictionary<Type, MethodInfo>` dictionaries (`s_withMethodCache`, `s_withoutMethodCache`), eliminating repeated reflection allocations on every `Build()` call.
+
+---
+
+## [2024.1] — initial release
+
+- Initial release of Morpeh.Queries.
+- Lambda-based `ForEach` and `ForEachParallel` queries.
+- Jobs & Burst support via `ScheduleJob`.
+- World Events and Entity Events system.
+- `QueryBuilderGlobals` for project-wide filter constraints.
+- Automatic query validation (`QueryHelper`).

CHANGELOG.md.meta

@@ -66,25 +66,27 @@ public void Dispose()
         public CompiledQuery(Filter filter)
         {
             this.filter = filter;
-            hasFilter = filter.excludedTypeIds.Length > 0 || filter.includedTypeIds.Length > 0;
+            // In Morpeh 2024.1.1+, an empty filter (no includes/excludes) matches ALL archetypes,
+            // so we always use filter-based iteration instead of the raw EntityData[] path.
+            hasFilter = true;
         }
 
         public bool IsEmpty()
         {
-            if (!hasFilter)
-                return filter.world.entities.Length == 0;
-
             return filter.IsEmpty();
         }
 
         public WorldEntitiesEnumerator GetEnumerator()
         {
-            if (!hasFilter)
-                return new WorldEntitiesEnumerator(filter.world.entities);
-
             return new WorldEntitiesEnumerator(filter.GetEnumerator());
         }
 
+        /// <summary>
+        /// Returns the total number of entities matched by this query.
+        /// Note: this iterates all archetypes, prefer IsEmpty() if you only need an emptiness check.
+        /// </summary>
+        public int Count() => filter.GetLengthSlow();
+
         public NativeFilter AsNative()
         {
             return filter.AsNative();

Core/CompiledQuery.cs

@@ -1,4 +1,6 @@
-using System.Reflection;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
 
 namespace Scellecs.Morpeh
 {
@@ -7,6 +9,10 @@ public class QueryBuilder
         private static readonly MethodInfo FILTER_WITH_METHOD_INFO = typeof(FilterBuilder).GetMethod("With");
         private static readonly MethodInfo FILTER_WITHOUT_METHOD_INFO = typeof(FilterBuilder).GetMethod("Without");
 
+        // Cache closed-generic MethodInfos to avoid MakeGenericMethod allocations on every Build() call
+        private static readonly Dictionary<Type, MethodInfo> s_withMethodCache = new();
+        private static readonly Dictionary<Type, MethodInfo> s_withoutMethodCache = new();
+
         private readonly IQuerySystem m_querySystem;
         internal FilterBuilder filterBuilder;
 
@@ -28,19 +34,39 @@ public CompiledQuery Build()
                 if (QueryBuilderGlobals.TYPES_TO_REQUIRE.Count > 0)
                 {
                     for (var i = 0; i < QueryBuilderGlobals.TYPES_TO_REQUIRE.Count; i++)
-                        filterBuilder = (FilterBuilder)FILTER_WITH_METHOD_INFO.MakeGenericMethod(QueryBuilderGlobals.TYPES_TO_REQUIRE[i]).Invoke(filterBuilder, new object[] { filterBuilder });
+                    {
+                        var type = QueryBuilderGlobals.TYPES_TO_REQUIRE[i];
+                        if (!s_withMethodCache.TryGetValue(type, out var method))
+                            s_withMethodCache[type] = method = FILTER_WITH_METHOD_INFO.MakeGenericMethod(type);
+                        filterBuilder = (FilterBuilder)method.Invoke(filterBuilder, null);
+                    }
                 }
 
                 if (QueryBuilderGlobals.TYPES_TO_IGNORE.Count > 0)
                 {
                     for (var i = 0; i < QueryBuilderGlobals.TYPES_TO_IGNORE.Count; i++)
-                        filterBuilder = (FilterBuilder)FILTER_WITHOUT_METHOD_INFO.MakeGenericMethod(QueryBuilderGlobals.TYPES_TO_IGNORE[i]).Invoke(filterBuilder, new object[] { filterBuilder });
+                    {
+                        var type = QueryBuilderGlobals.TYPES_TO_IGNORE[i];
+                        if (!s_withoutMethodCache.TryGetValue(type, out var method))
+                            s_withoutMethodCache[type] = method = FILTER_WITHOUT_METHOD_INFO.MakeGenericMethod(type);
+                        filterBuilder = (FilterBuilder)method.Invoke(filterBuilder, null);
+                    }
                 }
             }
 
             return new CompiledQuery(filterBuilder.Build());
         }
 
+        /// <summary>
+        /// Applies a Morpeh IFilterExtension to this query.
+        /// Allows reusing pre-defined filter compositions across multiple queries.
+        /// </summary>
+        public QueryBuilder Extend<T>() where T : struct, IFilterExtension
+        {
+            filterBuilder = filterBuilder.Extend<T>();
+            return this;
+        }
+
         #region Parameters
 
         public QueryBuilder SkipValidation(bool skipValidation)

Core/QueryBuilder.cs

@@ -0,0 +1,9 @@
+namespace Scellecs.Morpeh
+{
+    /// <summary>
+    /// Base class for cleanup systems that run at the end of the frame (LateUpdate order).
+    /// </summary>
+    public abstract class QueryCleanupSystem : QuerySystem, ICleanupSystem
+    {
+    }
+}

Core/QueryCleanupSystem.cs

@@ -0,0 +1,11 @@
+namespace Scellecs.Morpeh
+{
+    /// <summary>
+    /// Base class for systems that run in FixedUpdate.
+    /// Inherit from this instead of QuerySystem when registering via group.AddSystem
+    /// and you need physics-step timing.
+    /// </summary>
+    public abstract class QueryFixedSystem : QuerySystem, IFixedSystem
+    {
+    }
+}

Core/QueryCleanupSystem.cs.meta

@@ -39,12 +39,18 @@ internal static void ValidateRequest(QueryBuilder queryBuilder, CompiledQuery co
             foreach (var requestedTypeInfo in requestedTypeInfosToValidate)
             {
                 if (!compiledQuery.filter.includedTypeIdsLookup.IsSet(requestedTypeInfo.typeId))
+                {
                     Debug.LogError(
                         $"You're expecting a component [<b>{requestedTypeInfo.type.Name}</b>] in your query in [<b>{queryBuilder.System.GetType().Name}</b>], but the query is <b>missing</b> this parameter. Please add it to the query first!");
+                    hasProblems = true;
+                }
 
                 if (compiledQuery.filter.excludedTypeIdsLookup.IsSet(requestedTypeInfo.typeId))
+                {
                     Debug.LogError(
                         $"You're expecting a component [<b>{requestedTypeInfo.type.Name}</b>] in your query in [<b>{queryBuilder.System.GetType().Name}</b>], but the query is <b>deliberately excluded</b> this parameter. Please remove it from the query or from the ForEach lambda!");
+                    hasProblems = true;
+                }
             }
 
             if (hasProblems)

Core/QueryFixedSystem.cs

@@ -0,0 +1,9 @@
+namespace Scellecs.Morpeh
+{
+    /// <summary>
+    /// Base class for systems that run in LateUpdate.
+    /// </summary>
+    public abstract class QueryLateSystem : QuerySystem, ILateSystem
+    {
+    }
+}