feat(integration): top-level 'and' filter combinator + range scenario

Both runners' filter DSL now recognize a top-level `and: [filter, filter, ...]`
that composes child filters with AND. Closes an undocumented cross-port
divergence: applying two ops to one field (`{ priceCents: { gte: 3000, lte: 7000 } }`)
silently meant first-wins in TS and all-ANDed in C#. Range queries now have
one explicit shape that both ports execute identically.

- query-scenario.ts toRuntimeFilter: recognize `and` array at top level,
  recurse and emit `$and` to runtime-ts (which already supports it via
  compileFilter). Filter type loosened to `Record<string, unknown>` since
  the value shape now varies (op-dict vs filter array).
- DbContextAdapter.ApplyFilter: extracted BuildFilterBody helper; on
  `"and"` key compose children with Expression.AndAlso (recursive).
- queries/filter-range-and.yaml: two queries — price-range (gte + lte on
  same field) and published-and-cheaper-than-5k (two fields with two ops).
- README: documented the AND combinator + why range queries can't use the
  two-ops-on-one-field shorthand. `or` left as a future combinator (both
  runtime adapters would need to grow it).

`or` deliberately not added — both runtime-ts compileFilter and the C#
adapter currently understand only `and`. Add when a scenario needs it.

Gates: TS integration 12/12, C# integration 12/12.

Author: dmealing

fixtures/persistence-conformance/README.md

@@ -134,7 +134,19 @@ Same vocabulary as the cross-language filter spec (Project D):
 | `like`   | SQL LIKE (string fields only) |
 | `isNull` | true → IS NULL, false → IS NOT NULL |
 
-Multiple field filters compose with AND.
+Multiple field filters compose with AND. To compose **multiple ops on the same
+field** (e.g. a range query) use an explicit `and:` block — applying two ops
+directly to one field is undefined across runtimes:
+
+```yaml
+filter:
+  and:
+    - { priceCents: { gte: 3000 } }
+    - { priceCents: { lte: 7000 } }
+```
+
+`and` is the only logical combinator today; `or` would require both runner
+adapters and `runtime-ts`' `compileFilter` to grow it first.
 
 ## Result format
 

fixtures/persistence-conformance/queries/filter-range-and.yaml

@@ -0,0 +1,35 @@
+name: filter-range-and
+description: |
+  Range query via the top-level `and` combinator — composes child filters with
+  AND. Required because applying two ops to one field (e.g. priceCents.gte +
+  priceCents.lte) produces ambiguous behavior across runtimes: TS's
+  query-builder takes only the first op, while a naive C# adapter would AND
+  both. The DSL pins one shape: explicit `and: [...]`.
+seed-data: |
+  INSERT INTO "programs" ("id", "title", "priceCents", "status", "createdAt") VALUES
+    (1, 'Foundations', 4999, 'PUBLISHED', '2026-05-01T10:00:00'),
+    (2, 'Strength',    7999, 'PUBLISHED', '2026-05-02T10:00:00'),
+    (3, 'Mobility',    2999, 'DRAFT',     '2026-05-03T10:00:00'),
+    (4, 'Archived',    1999, 'ARCHIVED',  '2026-05-04T10:00:00');
+queries:
+  - name: price-range-3k-to-7k
+    op: list
+    entity: Program
+    filter:
+      and:
+        - { priceCents: { gte: 3000 } }
+        - { priceCents: { lte: 7000 } }
+    sort: [{ field: id, dir: asc }]
+    expect:
+      - { id: "1", title: "Foundations", priceCents: "4999", status: "PUBLISHED", createdAt: "2026-05-01T10:00:00" }
+
+  - name: published-and-cheaper-than-5k
+    op: list
+    entity: Program
+    filter:
+      and:
+        - { status: { eq: "PUBLISHED" } }
+        - { priceCents: { lt: 5000 } }
+    sort: [{ field: id, dir: asc }]
+    expect:
+      - { id: "1", title: "Foundations", priceCents: "4999", status: "PUBLISHED", createdAt: "2026-05-01T10:00:00" }

server/csharp/MetaObjects.IntegrationTests/Runner/DbContextAdapter.cs

@@ -94,10 +94,41 @@ private static PropertyInfo Property(Type entity, string fieldName) =>
     private static IQueryable<T> ApplyFilter<T>(IQueryable<T> queryable, IReadOnlyDictionary<string, object?> filter)
     {
         var param = Expression.Parameter(typeof(T), "x");
+        var body = BuildFilterBody(typeof(T), param, filter);
+        if (body is null) return queryable;
+        var lambda = Expression.Lambda<Func<T, bool>>(body, param);
+        return queryable.Where(lambda);
+    }
+
+    // Accepts either an IReadOnlyDictionary (the top-level Filter shape) or an
+    // IDictionary (what AsStringKeyedDict returns for nested `and` children).
+    private static Expression? BuildFilterBody(
+        Type entityType, ParameterExpression param, IEnumerable<KeyValuePair<string, object?>> filterEntries)
+    {
+        var filter = filterEntries.ToDictionary(kv => kv.Key, kv => kv.Value);
+        // Top-level `and: [filter, filter, ...]` composes child filters with AndAlso.
+        // Compose-by-AND is the only logical combinator today; `or` would need both
+        // runtime-ts compileFilter AND this adapter to grow it first.
+        if (filter.TryGetValue("and", out var andValue) && andValue is System.Collections.IEnumerable list)
+        {
+            Expression? combined = null;
+            foreach (var child in list)
+            {
+                var childDict = AsStringKeyedDict(child)
+                    ?? throw new InvalidOperationException(
+                        "`and` list elements must be filter objects (got " +
+                        $"{child?.GetType().Name ?? "null"})");
+                var childExpr = BuildFilterBody(entityType, param, childDict);
+                if (childExpr is null) continue;
+                combined = combined is null ? childExpr : Expression.AndAlso(combined, childExpr);
+            }
+            return combined;
+        }
+
         Expression? body = null;
         foreach (var (field, opsRaw) in filter)
         {
-            var prop = Property(typeof(T), field);
+            var prop = Property(entityType, field);
             var propExpr = Expression.Property(param, prop);
             // YamlDotNet hands back Dictionary<object, object?> for nested mappings
             // when the parent is typed as object?; normalize both shapes here so the
@@ -111,9 +142,7 @@ private static IQueryable<T> ApplyFilter<T>(IQueryable<T> queryable, IReadOnlyDi
                 body = body is null ? clause : Expression.AndAlso(body, clause);
             }
         }
-        if (body is null) return queryable;
-        var lambda = Expression.Lambda<Func<T, bool>>(body, param);
-        return queryable.Where(lambda);
+        return body;
     }
 
     private static IDictionary<string, object?>? AsStringKeyedDict(object? raw) => raw switch

server/typescript/packages/integration-tests/src/query-scenario.ts

@@ -111,11 +111,20 @@ async function execute(om: ObjectManager, spec: QuerySpec): Promise<unknown> {
   return await om.findMany(spec.entity, filter, opts);
 }
 
-function toRuntimeFilter(filter: Record<string, Record<string, unknown>>): Filter {
+function toRuntimeFilter(filter: Record<string, unknown>): Filter {
+  // Top-level `and: [filter, filter, ...]` lowers to the runtime's `$and` form.
+  // Compose-by-AND is the only logical combinator supported today; `or` would
+  // need both runtime-ts compileFilter AND the C# adapter to grow it first.
+  if (Array.isArray(filter.and)) {
+    return {
+      $and: (filter.and as Record<string, unknown>[]).map(toRuntimeFilter),
+    } as Filter;
+  }
+  // Otherwise: each top-level key is a field name; its value is a {op: value} object.
   const out: Record<string, unknown> = {};
   for (const [field, ops] of Object.entries(filter)) {
     const ops$: Record<string, unknown> = {};
-    for (const [op, value] of Object.entries(ops)) ops$["$" + op] = value;
+    for (const [op, value] of Object.entries(ops as Record<string, unknown>)) ops$["$" + op] = value;
     out[field] = ops$;
   }
   return out as Filter;

server/typescript/packages/integration-tests/src/scenario.ts

@@ -38,7 +38,12 @@ export interface QuerySpec {
   readonly op: "list" | "get" | "count";
   readonly entity: string;
   readonly by: Record<string, unknown> | null;
-  readonly filter: Record<string, Record<string, unknown>> | null;
+  /**
+   * Either `{ field: { op: value } }` (each top-level key is a field name) or
+   * `{ and: [filter, filter, ...] }` (compose by AND). Mixed forms are
+   * ill-formed — pick one at each level.
+   */
+  readonly filter: Record<string, unknown> | null;
   readonly sort: ReadonlyArray<{ field: string; dir: "asc" | "desc" }> | null;
   readonly limit: number | null;
   readonly offset: number | null;
@@ -97,7 +102,7 @@ export function loadQuery(yamlPath: string): QueryScenario {
       op: required(q.op, yamlPath, "query.op") as QuerySpec["op"],
       entity: required(q.entity, yamlPath, "query.entity"),
       by: (q.by as Record<string, unknown> | undefined) ?? null,
-      filter: (q.filter as Record<string, Record<string, unknown>> | undefined) ?? null,
+      filter: (q.filter as Record<string, unknown> | undefined) ?? null,
       sort: q.sort
         ? q.sort.map((s) => ({ field: s.field ?? "", dir: (s.dir as "asc" | "desc") ?? "asc" }))
         : null,