@@ -1,3 +1,35 @@
+# 6.0.0
+
+6.0.0 includes everything from the `6.0.0-beta1` – `6.0.0-beta8` releases — see the beta sections below for full details and the complete list of breaking changes. A summary of the big items:
+
+## Highlights
+
+- **Partial results & spec compliance** (beta1) — top-level fields execute independently; if one fails you get the successful fields' data plus error details for the failed ones, and `data` is `null` when an error prevents a valid response, per the GraphQL spec. `MapGraphQL` follows the [GraphQL-over-HTTP spec](https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md) by default.
+- **New async model & cancellation** (beta1) — `.ResolveAsync<>()` for async fields, end-to-end `CancellationToken` support (passed through `ExecuteRequestAsync` and into your resolvers), and async subscription setup (`Task<IObservable<T>>`).
+- **Query protection** (beta3) — opt-in pre-execution guards (`MaxQueryDepth`, `MaxFieldSelections`, `MaxFieldAliases`, `MaxQueryComplexity`), per-field complexity scoring via `field.SetComplexity(...)`, and per-field rate limiting via `field.AddRateLimit(...)` with a `PartitionedRateLimiter`-backed implementation in `EntityGraphQL.AspNet`.
+- **New `UseAggregate()` field extension** (beta8) — expose `count`/`min`/`max`/`sum`/`average` over a collection field, translated to a single SQL query under EF. Placement adapts to the field (attaches to a paging wrapper, wraps as `{ items, aggregate }`, or an additive sibling field), and it supports aggregating service-backed and bulk-resolved fields via the two-pass execution model.
+- **Filtering improvements** — reference service fields in filters (#303), GraphQL variables in filters (`filter: "name == $searchTerm"`, #396), `selectMany` for nested collections, generic custom type converters (#476), better nullable numeric comparisons (#484), and filtering by paged child fields (#378, below).
+- **Paging & EF performance** — the `COUNT` query only runs when the selection needs the total, `hasNextPage` alone is answered with a cheap `EXISTS` query, and connection cursor assignment computes its argument math once per request. Page queries select only the requested columns with parameterized paging.
+- **New GraphQL document parser** (beta3) — replaced the third-party parser; adds document descriptions from the September 2025 spec; structured error source `locations` in responses.
+- **Targets** — adds `net10.0`; `EntityGraphQL.AspNet` drops `net6.0`/`net7.0` (the core `EntityGraphQL` package still targets `netstandard2.1` for older runtimes).
+
+## Breaking changes summary
+
+Each is detailed in the beta section it shipped in:
+
+- Partial-results behavior and `AddGraphQLValidator` now registering `IGraphQLValidator` as transient (beta1)
+- `MapGraphQL` spec-following behavior is the default (beta1); removed previously-obsolete members; filter support via `ArgumentHelper.EntityQuery` removed — use `UseFilter()` (beta1)
+- `AddGraphQLOptions<T>` restructured to composition (`options.Builder` / `options.Schema`), `ConfigureSchema(...)` methods, and `AddGraphQLSchema()` returning a `GraphQLSchemaBuilder<T>` for chaining `ConfigureGraphQLSchema(...)` (beta3/beta5)
+- Authorization refactored to a keyed data structure; role/policy helpers replace the roles constructor (beta3)
+- `IFieldExtension` hooks take context objects instead of positional parameters (beta4)
+- Renames: `SchemaBuilderSchemaOptions` → `SchemaProviderOptions` (beta3), `ExecutionOptions.MaxQueryNodes` → `MaxFieldSelections`, `UserKeySelector` → `RateLimitUserKeySelector` (beta6), `ExecutableDirectiveLocation` enum fields to C# style (beta3)
+- Default serializers use `JsonSerializerDefaults.Web` (beta6)
+
+## Changes since beta8
+
+- #378 - Filtering by a paged child field now works. Within a filter expression a field using `UseOffsetPaging()`/`UseConnectionPaging()` resolves to its underlying collection (the page wrapper only exists in the GraphQL schema), so `enquiries(filter: "enquirerDaps.count() > 0")`, `"enquirerDaps.items.count() > 0"` (`items`/`edges` are the collection) and `"enquirerDaps.totalItems > 0"` (`totalItems`/`totalCount` map to `Count()`) all compile and translate to SQL under EF. Previously these failed with `Method 'count' not found on current context 'OffsetPage'` or a `NullReferenceException`. Other page metadata (e.g. `hasNextPage`) raises a clear error when used in a filter.
+
+
 # 6.0.0-beta8
 
 ## New Features
 
@@ -345,6 +345,19 @@ With variables:
 }
 ```
 
+## Paged Fields in Filters
+
+A field using `UseOffsetPaging()`/`UseConnectionPaging()` returns a page wrapper type in the GraphQL schema, but that wrapper can't execute inside a filter (or translate to SQL). So within a filter expression a paged field resolves to its **underlying collection**:
+
+```graphql
+# enquirerDaps uses UseOffsetPaging - all of these are equivalent in a filter:
+enquiries(filter: "enquirerDaps.count() > 0")
+enquiries(filter: "enquirerDaps.items.count() > 0")  # items/edges are the collection itself
+enquiries(filter: "enquirerDaps.totalItems > 0")     # totalItems/totalCount map to Count()
+```
+
+Note the collection is the *unfiltered* source — any `filter` argument passed to the paged field in the query applies to that field's own results, not to the parent's filter. Other page metadata (e.g. `hasNextPage`) is not available in filters.
+
 ## Service Fields in Filters
 
 When using the filter extension with fields that resolve data from services (using `Resolve<TService>()`) and have two-pass execution enabled (`ExecuteServiceFieldsSeparately = true`, which is the default), EntityGraphQL automatically handles filter splitting to optimize query performance.
 
@@ -4,7 +4,7 @@
     <AssemblyName>EntityGraphQL.AspNet</AssemblyName>
     <PackageId>EntityGraphQL.AspNet</PackageId>
     <LangVersion>13</LangVersion>
-    <PackageVersion>6.0.0-beta8</PackageVersion>
+    <PackageVersion>6.0.0</PackageVersion>
     <Description>Contains ASP.NET extensions and middleware for EntityGraphQL</Description>
     <Authors>Luke Murray</Authors>
     <PackageProjectUrl>https://github.com/lukemurray/EntityGraphQL</PackageProjectUrl>
 
@@ -18,4 +18,12 @@ public EqlCompileContext(CompileContext compileContext)
 
     public List<IField> ServiceFieldDependencies { get; } = new();
     public Expression? OriginalContext { get; set; }
+
+    /// <summary>
+    /// Expressions produced by resolving a paged field (UseOffsetPaging/UseConnectionPaging) in a filter -
+    /// they are the field's underlying collection (the Page/Connection wrapper only exists in the GraphQL
+    /// schema). Tracked so a following items/edges access can be treated as identity and totalItems/totalCount
+    /// as Count(). See IdentityExpression.
+    /// </summary>
+    public HashSet<Expression> PagedFieldExpressions { get; } = new();
 }
@@ -2,7 +2,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using EntityGraphQL.Extensions;
 using EntityGraphQL.Schema;
+using EntityGraphQL.Schema.FieldExtensions;
 
 namespace EntityGraphQL.Compiler.EntityQuery.Grammar;
 
@@ -30,6 +32,24 @@ internal static Expression MakePropertyCall(Expression context, ISchemaProvider?
                 return MakeConstantFromIdentity(context, schema, name, requestContext);
             }
         }
+
+        // the context is the underlying collection of a paged field (see below). The Page/Connection wrapper
+        // fields only exist in the GraphQL schema - map them onto the collection
+        if (compileContext.PagedFieldExpressions.Contains(context))
+        {
+            if (string.Equals(name, "items", StringComparison.OrdinalIgnoreCase) || string.Equals(name, "edges", StringComparison.OrdinalIgnoreCase))
+                return context; // identity - the collection is the items
+            if (string.Equals(name, "totalItems", StringComparison.OrdinalIgnoreCase) || string.Equals(name, "totalCount", StringComparison.OrdinalIgnoreCase))
+            {
+                var elementType = context.Type.GetEnumerableOrArrayType()!;
+                return Expression.Call(context.Type.IsGenericTypeQueryable() ? typeof(Queryable) : typeof(Enumerable), nameof(Enumerable.Count), [elementType], context);
+            }
+            throw new EntityGraphQLException(
+                GraphQLErrorCategory.DocumentError,
+                $"Field '{name}' is not supported on a paged field within a filter. The paged field resolves to its underlying collection - use it directly (e.g. field.count()) or via items/edges/totalItems/totalCount."
+            );
+        }
+
         // we have a schema we follow it for fields etc
         var schemaType = schema.GetSchemaType(context.Type, false, requestContext);
 
@@ -44,6 +64,22 @@ internal static Expression MakePropertyCall(Expression context, ISchemaProvider?
         }
         var gqlField = schemaType.GetField(name, requestContext);
 
+        // A paged field's resolve is the Page/Connection wrapper object which only exists for the GraphQL
+        // schema - it cannot execute inside a filter (or translate to SQL). Within a filter the field means
+        // the underlying collection, so use the pre-paging resolve expression and remember it so a following
+        // items/edges/totalItems/totalCount access can be mapped (above). See GitHub issue #378.
+        var pagingExt = gqlField.Extensions.FirstOrDefault(e => e is OffsetPagingExtension or ConnectionPagingExtension);
+        if (pagingExt != null && gqlField.FieldParam != null)
+        {
+            var original = pagingExt is OffsetPagingExtension offset ? offset.OriginalFieldExpression : ((ConnectionPagingExtension)pagingExt).OriginalFieldExpression;
+            if (original != null)
+            {
+                var collection = new Util.ParameterReplacer().Replace(original, gqlField.FieldParam, context);
+                compileContext.PagedFieldExpressions.Add(collection);
+                return collection;
+            }
+        }
+
         var isServiceField = gqlField.Services.Count > 0;
 
         Expression? exp;
 
@@ -4,7 +4,7 @@
     <LangVersion>13.0</LangVersion>
     <AssemblyName>EntityGraphQL</AssemblyName>
     <PackageId>EntityGraphQL</PackageId>
-    <PackageVersion>6.0.0-beta8</PackageVersion>
+    <PackageVersion>6.0.0</PackageVersion>
     <Description>A GraphQL library for .NET. Compiles queries into .NET Expressions (LinqProvider) for runtime execution against object graphs. E.g. against an ORM data model (EntityFramework or others) or just an in-memory object.</Description>
     <Authors>Luke Murray</Authors>
     <PackageProjectUrl>https://github.com/lukemurray/EntityGraphQL</PackageProjectUrl>
 
@@ -34,4 +34,33 @@ public void SupportNullableDateTime()
         var person = Enumerable.First(people);
         Assert.Equal(33, person.id);
     }
+
+    [Fact]
+    public void GitHubIssue378_FilterOnPagedChildFieldTranslatesToSql()
+    {
+        // filtering by a paged child field ("movies.items.count() > 0") - the filter resolves the paged
+        // field to its underlying collection so it executes against EF (sqlite throws if untranslatable)
+        var schema = SchemaBuilder.FromObject<TestDbContext>();
+        schema.Type<Actor>().GetField("movies", null).UseOffsetPaging();
+        schema.Query().ReplaceField("actors", db => db.Actors, "Get all actors").UseFilter();
+
+        using var factory = new TestDbContextFactory();
+        var data = factory.CreateContext();
+        var movie = new Movie("A movie");
+        data.Add(new Actor("With movies") { Id = 1, Movies = [movie] });
+        data.Add(new Actor("Without movies") { Id = 2 });
+        data.SaveChanges();
+
+        var result = schema.ExecuteRequestWithContext(
+            new QueryRequest { Query = @"{ actors(filter: ""movies.items.count() > 0"") { id name } }" },
+            data,
+            null,
+            null
+        );
+
+        Assert.Null(result.Errors);
+        dynamic actors = ((IDictionary<string, object>)result.Data!)["actors"]!;
+        Assert.Equal(1, Enumerable.Count(actors));
+        Assert.Equal(1, Enumerable.First(actors).id);
+    }
 }
@@ -215,7 +215,7 @@ public void TestUseFilterOnFieldWithExistingArgumentsAddsFilterArgumentWithoutDe
         Assert.DoesNotContain("filter: String = ", sdl);
     }
 
-    [Fact(Skip = "GitHub Issue #378 - Fix not implemented yet")]
+    [Fact]
     public void ReproducesGitHubIssue378_CountMethodNotFoundOnOffsetPage()
     {
         var schema = SchemaBuilder.FromObject<IncidentContext>();
@@ -269,7 +269,7 @@ public void ReproducesGitHubIssue378_CountMethodNotFoundOnOffsetPage()
         Assert.Empty(secondEnquiry.enquirerDaps.items);
     }
 
-    [Fact(Skip = "GitHub Issue #378 - Fix not implemented yet")]
+    [Fact]
     public void ReproducesGitHubIssue378_CountMethodNotFoundOnConnectionPage()
     {
         var schema = SchemaBuilder.FromObject<IncidentContext>();
@@ -312,6 +312,58 @@ public void ReproducesGitHubIssue378_CountMethodNotFoundOnConnectionPage()
         Assert.Equal(3, secondEnquiry.node.id);
     }
 
+    [Fact]
+    public void GitHubIssue378_PagedFieldUsedDirectlyInFilter()
+    {
+        // the paged field resolves to its underlying collection in a filter, so count()/any() work directly
+        // (the user's first attempt in the issue) and totalItems maps to Count()
+        var schema = SchemaBuilder.FromObject<IncidentContext>();
+        schema.Type<Incident>().GetField("enquiries", null).UseFilter().UseOffsetPaging();
+        schema.Type<Enquiry>().GetField("enquirerDaps", null).UseFilter().UseOffsetPaging();
+
+        var context = new IncidentContext().FillWithIncidentData();
+
+        var direct = schema.ExecuteRequestWithContext(
+            new QueryRequest { Query = @"query { incident(id: 1) { enquiries(filter: ""enquirerDaps.count() > 0"") { items { id } } } }" },
+            context,
+            null,
+            null
+        );
+        Assert.Null(direct.Errors);
+        dynamic incident = ((IDictionary<string, object>)direct.Data!)["incident"];
+        Assert.Equal(2, Enumerable.Count(incident.enquiries.items));
+
+        var totalItems = schema.ExecuteRequestWithContext(
+            new QueryRequest { Query = @"query { incident(id: 1) { enquiries(filter: ""enquirerDaps.totalItems == 0"") { items { id } } } }" },
+            context,
+            null,
+            null
+        );
+        Assert.Null(totalItems.Errors);
+        dynamic incident2 = ((IDictionary<string, object>)totalItems.Data!)["incident"];
+        Assert.Equal(1, Enumerable.Count(incident2.enquiries.items)); // only enquiry id=2 has none
+        Assert.Equal(2, Enumerable.First(incident2.enquiries.items).id);
+    }
+
+    [Fact]
+    public void GitHubIssue378_UnsupportedPageFieldInFilterGivesClearError()
+    {
+        var schema = SchemaBuilder.FromObject<IncidentContext>();
+        schema.Type<Incident>().GetField("enquiries", null).UseFilter().UseOffsetPaging();
+        schema.Type<Enquiry>().GetField("enquirerDaps", null).UseFilter().UseOffsetPaging();
+
+        var context = new IncidentContext().FillWithIncidentData();
+        var result = schema.ExecuteRequestWithContext(
+            new QueryRequest { Query = @"query { incident(id: 1) { enquiries(filter: ""enquirerDaps.hasNextPage"") { items { id } } } }" },
+            context,
+            null,
+            null
+        );
+
+        Assert.NotNull(result.Errors);
+        Assert.Contains("not supported on a paged field", result.Errors![0].Message);
+    }
+
     private class IncidentContext
     {
         public List<Incident> Incidents { get; set; } = [];