@effect-app/infra 4.0.0-beta.33 → 4.0.0-beta.330

package/test/query.test.ts

@@ -1,25 +1,41 @@
 /* eslint-disable unused-imports/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, flow, Layer, Option, pipe, S, ServiceMap, Struct } from "effect-app"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { and, computed, count, expr, make, one, or, order, page, project, type ProjectableFromDomain, projectComputed, type QueryEnd, type QueryProjection, type QueryWhere, relation, toFilter, where } from "effect-app/Model/query"
+import { makeRepo } from "effect-app/Model/Repository"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
+import * as Option from "effect-app/Option"
+import * as S from "effect-app/Schema"
+import { setupRequestContextFromCurrent } from "effect-app/setupRequest"
+import { flow, pipe } from "effect/Function"
+import * as Redacted from "effect/Redacted"
+import * as Getter from "effect/SchemaGetter"
+import * as SchemaTransformation from "effect/SchemaTransformation"
+import * as Struct from "effect/Struct"
+import * as fs from "fs"
+import * as os from "os"
+import * as path from "path"
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
-import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { and, count, make, one, or, order, page, project, type QueryEnd, type QueryProjection, type QueryWhere, toFilter, where } from "../src/Model/query.js"
-import { makeRepo } from "../src/Model/Repository.js"
+import { DiskStoreLayer } from "../src/Store/Disk.js"
 import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
 import { SomeService } from "./fixtures.js"
 
+const TestStoreLive = Layer.merge(MemoryStoreLive, RepositoryRegistryLive)
+
 const str = S.Struct({ _tag: S.Literal("string"), value: S.String })
 const num = S.Struct({ _tag: S.Literal("number"), value: S.Finite })
 const someUnion = S.Union([str, num])
 
 export class Something extends S.Class<Something>("Something")({
-  id: S.StringId.withDefault,
+  id: S.StringId.withConstructorDefault,
   displayName: S.NonEmptyString255,
-  name: S.NullOr(S.NonEmptyString255).withDefault,
-  n: S.Date.withDefault,
-  union: someUnion.pipe(S.withDefaultConstructor(() => ({ _tag: "string" as const, value: "hi" })))
+  name: S.NullOr(S.NonEmptyString255).withConstructorDefault,
+  n: S.Date.withConstructorDefault,
+  union: someUnion.pipe(S.withConstructorDefault(Effect.succeed({ _tag: "string" as const, value: "hi" })))
 }) {}
 export declare namespace Something {
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -31,7 +47,7 @@ const q = make<Something.Encoded>()
     where("displayName", "Verona"),
     or(
       where("displayName", "Riley"),
-      and("n", "gt", "2021-01-01T00:00:00Z") // TODO: work with To type translation, so Date?
+      and("n", "gt", new Date("2021-01-01T00:00:00Z"))
     ),
     order("displayName"),
     page({ take: 10 }),
@@ -90,8 +106,8 @@ it("works", () => {
 
   const processed = memFilter(interpreted)(items.map((_) =>
     S.encodeUnknownSync(S.Struct({
-      ...Something.omit("displayName"),
-      displayName: S.Literal("Verona", "Riley")
+      ...Struct.omit(Something.fields, ["displayName"]),
+      displayName: S.Literals(["Verona", "Riley"])
     }))(_)
   ))
 
@@ -99,7 +115,7 @@ it("works", () => {
 })
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class SomethingRepo extends ServiceMap.Service<SomethingRepo>()("SomethingRepo", {
+class SomethingRepo extends Context.Service<SomethingRepo>()("SomethingRepo", {
   make: Effect.gen(function*() {
     return yield* makeRepo("Something", Something, {})
   })
@@ -112,7 +128,7 @@ class SomethingRepo extends ServiceMap.Service<SomethingRepo>()("SomethingRepo",
       })
     )
     .pipe(
-      Layer.provide(MemoryStoreLive)
+      Layer.provide(TestStoreLive)
     )
 }
 
@@ -131,7 +147,7 @@ it("works with repo", () =>
           where("displayName", "Verona"),
           or(
             where("displayName", "Riley"),
-            and("n", "gt", "2021-01-01T00:00:00Z") // TODO: work with To type translation, so Date?
+            and("n", "gt", new Date("2021-01-01T00:00:00Z"))
           ),
           order("displayName"),
           page({ take: 10 }),
@@ -158,13 +174,163 @@ it("works with repo", () =>
 
       expect(q1).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["id", "displayName"])))
       expect(q2).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["displayName"])))
+
+      const byDate = yield* somethingRepo.query(
+        where("n", new Date("2020-01-01T00:00:00.000Z"))
+      )
+      expect(byDate.map((_) => _.displayName)).toEqual(["Verona", "Riley"])
     })
     .pipe(
       Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.Default)),
       setupRequestContextFromCurrent(),
+      Effect.scoped,
       Effect.runPromise
     ))
 
+it("memory store round-trips Date/Set/Map via JSON codecs", () =>
+  Effect
+    .gen(function*() {
+      class Doc extends S.Class<Doc>("JsonCodecDoc")({
+        id: S.String,
+        at: S.Date,
+        tags: S.ReadonlySet(S.String),
+        meta: S.ReadonlyMap({ key: S.String, value: S.Finite })
+      }) {}
+      const at = new Date("2024-06-01T00:00:00.000Z")
+      const saved = new Doc({
+        id: "d1",
+        at,
+        tags: new Set(["a", "b"]),
+        meta: new Map([["n", 1]])
+      })
+      const repo = yield* makeRepo("JsonCodecDoc", Doc, { makeInitial: Effect.succeed([saved]) })
+      const found = yield* repo.find("d1")
+      expect(Option.isSome(found)).toBe(true)
+      if (Option.isSome(found)) {
+        expect(found.value.at.toISOString()).toBe(at.toISOString())
+        expect(found.value.tags).toEqual(new Set(["a", "b"]))
+        expect(found.value.meta).toEqual(new Map([["n", 1]]))
+      }
+      const byDate = yield* repo.query(where("at", at))
+      expect(byDate.map((_) => _.id)).toEqual(["d1"])
+      const byTag = yield* repo.query(where("tags", "includes", "b"))
+      expect(byTag.map((_) => _.id)).toEqual(["d1"])
+      const byKey = yield* repo.query(where("meta", "hasKey", "n"))
+      expect(byKey.map((_) => _.id)).toEqual(["d1"])
+      const byPair = yield* repo.query(where("meta", "hasKeyValue", ["n", 1]))
+      expect(byPair.map((_) => _.id)).toEqual(["d1"])
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+class Day {
+  readonly ymd: string
+  constructor(ymd: string) {
+    this.ymd = ymd
+  }
+}
+
+const DayFromSelf = S.declare((u): u is Day => u instanceof Day, {
+  expected: "Day",
+  toCodecJson: () =>
+    S.link<Day>()(
+      S.String,
+      {
+        decode: Getter.transform((s: string) => new Day(s)),
+        encode: Getter.transform((d: Day) => d.ymd)
+      }
+    )
+})
+
+it("memory store round-trips app native Encoded values via the document schema", () =>
+  Effect
+    .gen(function*() {
+      class Doc extends S.Class<Doc>("JsonCodecDayDoc")({
+        id: S.String,
+        day: DayFromSelf
+      }) {}
+      const day = new Day("2024-06-01")
+      const saved = new Doc({ id: "d1", day })
+      const repo = yield* makeRepo("JsonCodecDayDoc", Doc, { makeInitial: Effect.succeed([saved]) })
+      const found = yield* repo.find("d1")
+      expect(Option.isSome(found)).toBe(true)
+      if (Option.isSome(found)) {
+        expect(found.value.day).toBeInstanceOf(Day)
+        expect(found.value.day.ymd).toBe("2024-06-01")
+      }
+      expect(S.encodeSync(DayFromSelf)(day)).toBe(day)
+      expect(S.encodeSync(S.toCodecJson(DayFromSelf))(day)).toBe("2024-06-01")
+      const byDay = yield* repo.query(where("day", day))
+      expect(byDay.map((_) => _.id)).toEqual(["d1"])
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+it("memory store queries encodeKeys-renamed native Encoded fields", () =>
+  Effect
+    .gen(function*() {
+      class Doc extends S.Class<Doc>("JsonCodecEncodeKeysDayDoc")({
+        id: S.String,
+        day: DayFromSelf
+      }) {}
+      const schema = Doc.pipe(S.encodeKeys({ day: "the_day" }))
+      const day = new Day("2024-06-01")
+      const saved = new Doc({ id: "d1", day })
+      const repo = yield* makeRepo("JsonCodecEncodeKeysDayDoc", schema, { makeInitial: Effect.succeed([saved]) })
+      const byDay = yield* repo.query(where("the_day", day))
+      expect(byDay.map((_) => _.id)).toEqual(["d1"])
+      const byId = yield* repo.query(where("id", "in", ["d1"]))
+      expect(byId.map((_) => _.id)).toEqual(["d1"])
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+it("disk store round-trips Date/Set/Map via JSON codecs", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "effect-app-disk-json-"))
+  const diskLive = Layer.merge(
+    DiskStoreLayer({ url: Redacted.make(`disk://${dir}`), prefix: "", dbName: "test" }, dir),
+    RepositoryRegistryLive
+  )
+  return Effect
+    .gen(function*() {
+      class Doc extends S.Class<Doc>("JsonCodecDiskDoc")({
+        id: S.String,
+        at: S.Date,
+        tags: S.ReadonlySet(S.String),
+        meta: S.ReadonlyMap({ key: S.String, value: S.Finite })
+      }) {}
+      const at = new Date("2024-06-01T00:00:00.000Z")
+      const saved = new Doc({
+        id: "d1",
+        at,
+        tags: new Set(["a", "b"]),
+        meta: new Map([["n", 1]])
+      })
+      const repo = yield* makeRepo("JsonCodecDiskDoc", Doc, { makeInitial: Effect.succeed([saved]) })
+      const found = yield* repo.find("d1")
+      expect(Option.isSome(found)).toBe(true)
+      if (Option.isSome(found)) {
+        expect(found.value.at.toISOString()).toBe(at.toISOString())
+        expect(found.value.tags).toEqual(new Set(["a", "b"]))
+        expect(found.value.meta).toEqual(new Map([["n", 1]]))
+      }
+      const jsonFile = fs.readdirSync(dir).find((f) => f.endsWith(".json"))
+      expect(jsonFile).toBeDefined()
+      const raw = JSON.parse(fs.readFileSync(path.join(dir, jsonFile!), "utf8")) as Array<{
+        at: unknown
+        tags: unknown
+        meta: unknown
+      }>
+      expect(raw[0]?.at).toBe(at.toISOString())
+      expect(raw[0]?.tags).toEqual(["a", "b"])
+      expect(raw[0]?.meta).toEqual([["n", 1]])
+    })
+    .pipe(
+      Effect.provide(diskLive),
+      setupRequestContextFromCurrent(),
+      Effect.scoped,
+      Effect.runPromise
+    )
+    .finally(() => fs.rmSync(dir, { recursive: true, force: true }))
+})
+
 it("collect", () =>
   Effect
     .gen(function*() {
@@ -185,8 +351,8 @@ it("collect", () =>
                 })),
                 S.toType(S.Option(S.String)),
                 (_) =>
-                  _.displayName === "Riley" && _.n === "2020-01-01T00:00:00.000Z"
-                    ? Option.some(`${_.displayName}-${_.n}`)
+                  _.displayName === "Riley" && _.n.toISOString() === "2020-01-01T00:00:00.000Z"
+                    ? Option.some(`${_.displayName}-${_.n.toISOString()}`)
                     : Option.none()
               ),
               "collect"
@@ -204,7 +370,7 @@ it("collect", () =>
         QueryEnd<{
           readonly id: string
           readonly displayName: string
-          readonly n: string
+          readonly n: Date
           readonly union: {
             readonly _tag: "string"
             readonly value: string
@@ -233,18 +399,19 @@ it("collect", () =>
     .pipe(
       Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.Default)),
       setupRequestContextFromCurrent(),
+      Effect.scoped,
       Effect.runPromise
     ))
 
-class Person extends S.ExtendedTaggedClass<Person, Person.Encoded>()("person", {
+class Person extends S.TaggedClass<Person, Person.Encoded>()("person", {
   id: S.String,
   surname: S.String
 }) {}
-class Animal extends S.ExtendedTaggedClass<Animal, Animal.Encoded>()("animal", {
+class Animal extends S.TaggedClass<Animal, Animal.Encoded>()("animal", {
   id: S.String,
   surname: S.String
 }) {}
-class Test extends S.ExtendedTaggedClass<Test, Test.Encoded>()("test", {
+class Test extends S.TaggedClass<Test, Test.Encoded>()("test", {
   id: S.String
 }) {}
 
@@ -279,7 +446,7 @@ it(
         expect(result).toEqual([])
         expect(result2).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -377,7 +544,6 @@ it(
         // eslint-disable-next-line unused-imports/no-unused-vars
         const query5 = make<Union>().pipe(
           where("id", "bla"),
-          // @ts-expect-error cannot project over fields that are not in common between the union members (you must refine the union first)
           project(S.Struct({ id: S.String, a: S.Unknown }))
         )
         console.log(query5)
@@ -465,7 +631,7 @@ it(
 
         expect([]).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -508,7 +674,7 @@ it(
 
         expect([]).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -519,8 +685,8 @@ it(
         const schema = S.Struct({
           id: S.String,
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(() => new Date().toISOString()),
-            S.withConstructorDefault(() => Option.some(new Date()))
+            S.withDecodingDefault(Effect.sync(() => new Date())),
+            S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
         const repo = yield* makeRepo(
@@ -532,8 +698,8 @@ it(
         const outputSchema = S.Struct({
           id: S.Literal("123"),
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(() => new Date().toISOString()),
-            S.withConstructorDefault(() => Option.some(new Date()))
+            S.withDecodingDefault(Effect.sync(() => new Date())),
+            S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
 
@@ -541,9 +707,470 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
+it(
+  "project with encodeKeys in projection maps encoded keys",
+  () =>
+    Effect
+      .gen(function*() {
+        const schema = S.Struct({
+          id: S.String,
+          a: S.Number
+        })
+
+        const repo = yield* makeRepo(
+          "test",
+          schema,
+          {
+            makeInitial: Effect.sync(() => [{ id: "1", a: 1 }])
+          }
+        )
+
+        const outputSchema = S.Struct({ b: S.Number }).pipe(S.encodeKeys({ b: "a" }))
+
+        const result = yield* repo.query(project(outputSchema))
+
+        expect(result).toStrictEqual([{ b: 1 }])
+      })
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
+)
+
+it("projectComputed sets computed IR and forces project mode", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      state: S.Struct({
+        _tag: S.String
+      })
+    }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({
+        pickedCount: S.NonNegativeInt
+      }),
+      computed({
+        pickedCount: relation<S.Codec.Encoded<typeof baseSchema>>("items").count(where("state._tag", "Picked"))
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  expect(interpreted.mode).toBe("project")
+  expect(interpreted.select).toEqual([
+    {
+      key: "pickedCount",
+      computed: {
+        _tag: "relation-count",
+        path: "items",
+        filter: [{ t: "where", path: "items.-1.state._tag", op: "eq", value: "Picked" }]
+      }
+    }
+  ])
+  expect(interpreted.computed?.["pickedCount"]?._tag).toBe("relation-count")
+  expect(interpreted.computed?.["pickedCount"]?.path).toBe("items")
+  expect((interpreted.computed?.["pickedCount"] as { filter: unknown } | undefined)?.filter).toEqual([
+    { t: "where", path: "items.-1.state._tag", op: "eq", value: "Picked" }
+  ])
+})
+
+it("projectComputed validates extra computed keys", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ value: S.Number }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String }),
+      // @ts-expect-error extra computed keys are rejected statically; keep runtime guard covered
+      computed({
+        pickedCount: relation<S.Codec.Encoded<typeof baseSchema>>("items").count()
+      })
+    )
+  )
+  expect(() => toFilter(query, baseSchema)).toThrowError("Computed projection keys must exist in projection schema")
+})
+
+it("projectComputed constrains projection schema to encoded repo fields and computed outputs", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    name: S.String,
+    items: S.Array(S.Struct({ articleId: S.String, weight: S.Number }))
+  })
+  type Encoded = S.Codec.Encoded<typeof baseSchema>
+
+  make<Encoded>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        itemCount: S.Number,
+        hasItems: S.Boolean,
+        articleIds: S.Array(S.String)
+      }),
+      ({ relation }) => ({
+        itemCount: relation("items").count(),
+        hasItems: relation("items").any(),
+        articleIds: relation("items").collect("articleId")
+      })
+    )
+  )
+
+  make<Encoded>().pipe(
+    // @ts-expect-error missingField is neither an encoded repo field nor a computed projection
+    projectComputed(S.Struct({ missingField: S.String }), computed({}))
+  )
+
+  // Key presence only (not Encoded value types) — name: number is still projectable.
+  make<Encoded>().pipe(
+    projectComputed(
+      S.Struct({ name: S.Number }),
+      computed({})
+    )
+  )
+
+  // Computed field *value* types are not yet constrained against the expression
+  // result (only key presence). Keeping this as a documentation call site.
+  make<Encoded>().pipe(
+    projectComputed(
+      S.Struct({ itemCount: S.String }),
+      computed({ itemCount: relation<Encoded>("items").count() })
+    )
+  )
+
+  make<Encoded>().pipe(
+    projectComputed(
+      S.Struct({ itemCount: S.Number }),
+      // @ts-expect-error extra computed keys must exist in the projection schema
+      computed({
+        itemCount: relation<Encoded>("items").count(),
+        extraCount: relation<Encoded>("items").count()
+      })
+    )
+  )
+})
+
+it("projectComputed supports union projection schemas", () => {
+  const baseSchema = S.Union([
+    S.Struct({
+      _tag: S.Literal("open"),
+      id: S.String,
+      items: S.Array(S.Struct({ articleId: S.String, weight: S.Number }))
+    }),
+    S.Struct({
+      _tag: S.Literal("closed"),
+      id: S.String,
+      closedAt: S.String
+    })
+  ])
+  type Encoded = S.Codec.Encoded<typeof baseSchema>
+  const query = make<Encoded>().pipe(
+    projectComputed(
+      S.Union([
+        S.Struct({
+          _tag: S.Literal("open"),
+          id: S.String,
+          articleCount: S.Number,
+          weight: S.Number,
+          articleIds: S.Array(S.String)
+        }),
+        S.Struct({
+          _tag: S.Literal("closed"),
+          id: S.String,
+          closedAt: S.String
+        })
+      ]),
+      computed({
+        articleCount: relation<Encoded>("items").count(),
+        weight: relation<Encoded>("items").sum("weight"),
+        articleIds: relation<Encoded>("items").collect("articleId")
+      })
+    )
+  )
+
+  const interpreted = toFilter(query, baseSchema)
+  expect(interpreted.computed && Object.keys(interpreted.computed).toSorted()).toEqual([
+    "articleCount",
+    "articleIds",
+    "weight"
+  ])
+})
+
+/**
+ * MACS-SCANNER-API-KS class of bug: domain cancel omits pack/print ownership
+ * (`activeRequest`); a hand-built overview projection that still requires it on
+ * every branch must fail at the `projectComputed` call site, not in prod decode.
+ */
+it("projectComputed rejects state-owned fields required on the wrong tagged branch", () => {
+  const domain = S.Union([
+    S.Struct({
+      _tag: S.Literal("packing"),
+      id: S.String,
+      activeRequest: S.NullOr(S.String),
+      items: S.Array(S.Struct({ articleId: S.String }))
+    }),
+    S.Struct({
+      _tag: S.Literal("cancelled"),
+      id: S.String,
+      items: S.Array(S.Struct({ articleId: S.String }))
+    })
+  ])
+  type DomainEnc = S.Codec.Encoded<typeof domain>
+
+  // Good: activeRequest only on packing; cancel omits it; articleCount is computed.
+  make<DomainEnc>().pipe(
+    projectComputed(
+      S.Union([
+        S.Struct({
+          _tag: S.Literal("packing"),
+          id: S.String,
+          activeRequest: S.NullOr(S.String),
+          articleCount: S.Number
+        }),
+        S.Struct({
+          _tag: S.Literal("cancelled"),
+          id: S.String,
+          articleCount: S.Number
+        })
+      ]),
+      computed({
+        articleCount: relation<DomainEnc>("items").count()
+      })
+    )
+  )
+
+  make<DomainEnc>().pipe(
+    projectComputed(
+      S.Union([
+        S.Struct({
+          _tag: S.Literal("packing"),
+          id: S.String,
+          activeRequest: S.NullOr(S.String),
+          articleCount: S.Number
+        }),
+        S.Struct({
+          _tag: S.Literal("cancelled"),
+          id: S.String,
+          activeRequest: S.NullOr(S.String),
+          articleCount: S.Number
+        })
+      ]),
+      // @ts-expect-error activeRequest is not on domain cancelled — cannot project it there
+      computed({
+        articleCount: relation<DomainEnc>("items").count()
+      })
+    )
+  )
+})
+
+it("ProjectableFromDomain distributes over tagged union Encoded", () => {
+  type DomainEnc =
+    | { readonly _tag: "packing"; readonly id: string; readonly activeRequest: string | null }
+    | { readonly _tag: "cancelled"; readonly id: string }
+
+  type Good =
+    | { readonly _tag: "packing"; readonly id: string; readonly activeRequest: string | null; readonly n: number }
+    | { readonly _tag: "cancelled"; readonly id: string; readonly n: number }
+
+  type Bad =
+    | { readonly _tag: "packing"; readonly id: string; readonly activeRequest: string | null }
+    | { readonly _tag: "cancelled"; readonly id: string; readonly activeRequest: string | null }
+
+  type GoodCheck = ProjectableFromDomain<Good, DomainEnc, "n">
+  type BadCheck = ProjectableFromDomain<Bad, DomainEnc>
+
+  const _good: GoodCheck = undefined
+  // @ts-expect-error cancelled branch requires activeRequest not present on domain cancelled
+  const _bad: BadCheck = undefined as unknown
+  void _good
+  void _bad
+})
+
+it("ProjectableFromDomain allows dual same-tag domain variants", () => {
+  // EasyLife packing/closed: two domain shapes share `_tag` with different fields.
+  type DomainEnc =
+    | { readonly _tag: "packing"; readonly id: string; readonly packages: readonly string[] }
+    | { readonly _tag: "packing"; readonly id: string; readonly units: readonly string[] }
+    | { readonly _tag: "initial"; readonly id: string }
+
+  type Good =
+    | { readonly _tag: "packing"; readonly id: string; readonly packages: readonly string[] }
+    | { readonly _tag: "packing"; readonly id: string; readonly units: readonly string[] }
+
+  // Flat multi-tag + state-only field must still fail (batchId not on initial).
+  type BadFlat = {
+    readonly _tag: "packing" | "initial"
+    readonly id: string
+    readonly packages: readonly string[]
+  }
+
+  type GoodCheck = ProjectableFromDomain<Good, DomainEnc>
+  type BadFlatCheck = ProjectableFromDomain<BadFlat, DomainEnc>
+
+  const _good: GoodCheck = undefined
+  // @ts-expect-error packages is not on domain initial; multi-tag flat intersection rejects it
+  const _badFlat: BadFlatCheck = undefined as unknown
+  void _good
+  void _badFlat
+})
+
+it("projection schema with computed fields fails without computed map", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ value: S.Number }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    // @ts-expect-error missing computed keys are rejected; also not projectable from domain alone
+    projectComputed(S.Struct({ pickedCount: S.NonNegativeInt }), computed({}))
+  )
+  expect(() => toFilter(query, baseSchema)).toThrowError("Missing computed projections for schema keys")
+})
+
+it("projectComputed.every emits relation-every IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ state: S.Struct({ _tag: S.String }) }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ allPicked: S.Boolean }),
+      computed({
+        allPicked: relation<S.Codec.Encoded<typeof baseSchema>>("items").every(where("state._tag", "Picked"))
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  expect(interpreted.computed?.["allPicked"]?._tag).toBe("relation-every")
+  expect(interpreted.computed?.["allPicked"]?.path).toBe("items")
+  expect((interpreted.computed?.["allPicked"] as { filter: unknown } | undefined)?.filter).toEqual([
+    { t: "where", path: "items.-1.state._tag", op: "eq", value: "Picked" }
+  ])
+})
+
+it("projectComputed.distinctCount emits relation-distinct-count IR with field", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ rowId: S.String, state: S.Struct({ _tag: S.String }) }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ positionCount: S.NonNegativeInt }),
+      computed({
+        positionCount: relation<S.Codec.Encoded<typeof baseSchema>>("items").distinctCount(
+          "rowId",
+          where("state._tag", "neq", "cancelled")
+        )
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["positionCount"]
+  expect(ir?._tag).toBe("relation-distinct-count")
+  expect((ir as { field: string } | undefined)?.field).toBe("rowId")
+  expect((ir as { filter: unknown } | undefined)?.filter).toEqual([
+    { t: "where", path: "items.-1.state._tag", op: "neq", value: "cancelled" }
+  ])
+})
+
+it("projectComputed.sum emits relation-sum IR with field", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ weight: S.Number }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ totalWeight: S.Number }),
+      computed({ totalWeight: relation<S.Codec.Encoded<typeof baseSchema>>("items").sum("weight") })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["totalWeight"]
+  expect(ir?._tag).toBe("relation-sum")
+  expect((ir as { field: string } | undefined)?.field).toBe("weight")
+  expect((ir as { filter: unknown } | undefined)?.filter).toEqual([])
+})
+
+it("projectComputed.collect / collectDistinct emit relation-collect IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ articleId: S.String }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({
+        all: S.Array(S.String),
+        distinct: S.Array(S.String)
+      }),
+      computed({
+        all: relation<S.Codec.Encoded<typeof baseSchema>>("items").collect("articleId"),
+        distinct: relation<S.Codec.Encoded<typeof baseSchema>>("items").collectDistinct("articleId")
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const all = interpreted.computed?.["all"]
+  const distinct = interpreted.computed?.["distinct"]
+  expect(all?._tag).toBe("relation-collect")
+  expect((all as { distinct: boolean } | undefined)?.distinct).toBe(false)
+  expect(distinct?._tag).toBe("relation-collect")
+  expect((distinct as { distinct: boolean } | undefined)?.distinct).toBe(true)
+})
+
+it("projectComputed.sumExpr emits relation-sum-expr IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      weight: S.Number,
+      tradeUnit: S.Struct({ amount: S.Number, unit: S.String })
+    }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ total: S.Number }),
+      computed({
+        total: relation<S.Codec.Encoded<typeof baseSchema>>("items").sumExpr(
+          expr.mul(expr.field("weight"), expr.field("tradeUnit.amount"))
+        )
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["total"]
+  expect(ir?._tag).toBe("relation-sum-expr")
+  expect((ir as { expression: unknown } | undefined)?.expression).toEqual({
+    _tag: "mul",
+    left: { _tag: "field", field: "weight" },
+    right: { _tag: "field", field: "tradeUnit.amount" }
+  })
+})
+
+it("projectComputed.sumExprBy emits relation-sum-expr-by IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      weight: S.Number,
+      tradeUnit: S.Struct({ amount: S.Number, unit: S.String })
+    }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({
+        totals: S.Array(S.Struct({ unit: S.String, total: S.Number }))
+      }),
+      computed({
+        totals: relation<S.Codec.Encoded<typeof baseSchema>>("items").sumExprBy(
+          expr.mul(expr.field("weight"), expr.field("tradeUnit.amount")),
+          { unit: "tradeUnit.unit" }
+        )
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["totals"]
+  expect(ir?._tag).toBe("relation-sum-expr-by")
+  expect((ir as { unit: string } | undefined)?.unit).toBe("tradeUnit.unit")
+})
+
 it(
   "doesn't mess when refining fields",
   () =>
@@ -551,7 +1178,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Literal("a", "b", "c")
+          literals: S.Literals(["a", "b", "c"])
         })
 
         type Schema = typeof schema.Type
@@ -571,7 +1198,7 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -581,7 +1208,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Union([S.Literal("a", "b", "c"), S.Null])
+          literals: S.Union([S.Literals(["a", "b", "c"]), S.Null])
         })
 
         type Schema = typeof schema.Type
@@ -615,7 +1242,7 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -659,7 +1286,7 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it("remove null from one constituent of a tagged union", () =>
@@ -708,7 +1335,7 @@ it("remove null from one constituent of a tagged union", () =>
         })[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("refine 3", () =>
   Effect
@@ -746,7 +1373,7 @@ it("refine 3", () =>
       const resQuer1 = yield* repo.query(where("id", "AA"))
       expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("my test", () =>
   Effect
@@ -764,7 +1391,7 @@ it("my test", () =>
       )
       expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("refine inner without imposing a projection", () =>
   Effect
@@ -808,7 +1435,7 @@ it("refine inner without imposing a projection", () =>
         where("union._tag", "AA"),
         // But if I wanna the whole Data as output ignoring the inner refinement
         // I wanna be able to do so
-        project(S.Struct(Data.pick("union")))
+        project(Data.mapFields(Struct.pick(["union"])))
       )
 
       expectTypeOf(query2).toEqualTypeOf<
@@ -839,7 +1466,7 @@ it("refine inner without imposing a projection", () =>
         }[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("does not allow string queries on arrays", () =>
   Effect
@@ -873,8 +1500,51 @@ it("does not allow string queries on arrays", () =>
       expectTypeOf(good2).toEqualTypeOf<QueryWhere<Some, Some>>()
       expectTypeOf(good3).toEqualTypeOf<QueryWhere<Some, Some>>()
       expectTypeOf(good4).toEqualTypeOf<QueryWhere<Some, Some>>()
+
+      type Native = {
+        readonly id: string
+        readonly dates: Date[]
+        readonly dateSet: ReadonlySet<Date>
+        readonly tags: ReadonlySet<string>
+      }
+      const native = make<Native>()
+      const d = new Date("2020-01-01T00:00:00.000Z")
+      const n1 = native.pipe(where("dates", "includes", d))
+      const n2 = native.pipe(where("dateSet", "includes", d))
+      const n3 = native.pipe(where("tags", "includes", "a"))
+      const n4 = native.pipe(where("dates", "includes-any", [d]))
+      const n5 = native.pipe(where("dateSet", "includes-any", new Set([d])))
+      const n6 = native.pipe(where("id", "in", new Set(["x"])))
+      expectTypeOf(n1).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n2).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n3).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n4).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n5).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n6).toEqualTypeOf<QueryWhere<Native, Native>>()
+
+      type WithMap = {
+        readonly id: string
+        readonly meta: ReadonlyMap<string, number>
+      }
+      const mapped = make<WithMap>()
+      const m1 = mapped.pipe(where("meta", "hasKey", "n"))
+      const m2 = mapped.pipe(where("meta", "hasValue", 1))
+      const m3 = mapped.pipe(where("meta", "hasKeyValue", ["n", 1] as const))
+      const m4 = mapped.pipe(where("meta", "hasKey-any", ["n", "x"]))
+      const m5 = mapped.pipe(where("meta", "hasValue-all", new Set([1, 2])))
+      const m6 = mapped.pipe(where("meta", "hasKeyValue-any", [["n", 1] as const, ["x", 2] as const]))
+      expectTypeOf(m1).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m2).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m3).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m4).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m5).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m6).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      // @ts-expect-error cannot hasKey on a string field
+      mapped.pipe(where("id", "hasKey", "n"))
+      // @ts-expect-error hasKey value must be the map key type
+      mapped.pipe(where("meta", "hasKey", 1))
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("test array.length", () =>
   Effect
@@ -915,7 +1585,7 @@ it("test array.length", () =>
         QueryWhere<Something, Something>
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("distribution over union", () =>
   Effect
@@ -939,7 +1609,7 @@ it("distribution over union", () =>
         })[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("refine nested union", () =>
   Effect
@@ -980,7 +1650,158 @@ it("refine nested union", () =>
         }[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+it("find with transformed id", () =>
+  Effect
+    .gen(function*() {
+      const ConfiguratorId = S.NonEmptyString255
+
+      class PreconfigurationId extends S.Class<PreconfigurationId>("PreconfigurationId")({
+        configuratorId: ConfiguratorId,
+        label: S.NonEmptyString50
+      }) {}
+
+      const PreconfigurationIdFromString = S.NonEmptyString255.pipe(
+        S.decodeTo(
+          S.toType(PreconfigurationId),
+          SchemaTransformation.transformEffect({
+            decode: Effect.fnUntraced(function*(value) {
+              const values = value.split("_")
+              const label = yield* S.SchemaParser.decodeUnknownEffect(S.NonEmptyString50)(values.pop())
+              const configuratorId = yield* S.SchemaParser.decodeUnknownEffect(ConfiguratorId)(
+                values.join("_")
+              )
+              return new PreconfigurationId({ configuratorId, label })
+            }),
+            encode: (id) => Effect.succeed(S.NonEmptyString255(`${id.configuratorId}_${id.label}`))
+          })
+        ),
+        S.revealCodec
+      )
+
+      const Preconfiguration = S.Struct({
+        id: PreconfigurationIdFromString,
+        name: S.String
+      })
+
+      const repo = yield* makeRepo("Preconfiguration", Preconfiguration, { idKey: "id" as const })
+
+      const id = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("myConfigurator"),
+        label: S.NonEmptyString50("myLabel")
+      })
+      const item = { id, name: "test preconfig" }
+
+      yield* repo.saveAndPublish([item])
+
+      const found = yield* repo.find(id)
+      expect(Option.isSome(found)).toBe(true)
+      expect(Option.getOrThrow(found).name).toBe("test preconfig")
+      expect(Option.getOrThrow(found).id).toEqual(id)
+
+      const notFound = yield* repo.find(
+        new PreconfigurationId({
+          configuratorId: S.NonEmptyString255("other"),
+          label: S.NonEmptyString50("nope")
+        })
+      )
+      expect(Option.isNone(notFound)).toBe(true)
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+it("find with transformed id in tagged union", () =>
+  Effect
+    .gen(function*() {
+      const ConfiguratorId = S.NonEmptyString255
+
+      class PreconfigurationId extends S.Class<PreconfigurationId>("PreconfigurationId")({
+        configuratorId: ConfiguratorId,
+        label: S.NonEmptyString50
+      }) {}
+
+      const PreconfigurationIdFromString = S.NonEmptyString255.pipe(
+        S.decodeTo(
+          S.toType(PreconfigurationId),
+          SchemaTransformation.transformEffect({
+            decode: Effect.fnUntraced(function*(value) {
+              const values = value.split("_")
+              const label = yield* S.SchemaParser.decodeUnknownEffect(S.NonEmptyString50)(values.pop())
+              const configuratorId = yield* S.SchemaParser.decodeUnknownEffect(ConfiguratorId)(
+                values.join("_")
+              )
+              return new PreconfigurationId({ configuratorId, label })
+            }),
+            encode: (id) => Effect.succeed(S.NonEmptyString255(`${id.configuratorId}_${id.label}`))
+          })
+        ),
+        S.revealCodec
+      )
+
+      class Draft extends S.TaggedClass<Draft>()("Draft", {
+        id: PreconfigurationIdFromString,
+        name: S.String
+      }) {}
+
+      class Published extends S.TaggedClass<Published>()("Published", {
+        id: PreconfigurationIdFromString,
+        name: S.String,
+        publishedAt: S.String
+      }) {}
+
+      class Archived extends S.TaggedClass<Archived>()("Archived", {
+        id: PreconfigurationIdFromString,
+        name: S.String,
+        archivedAt: S.String
+      }) {}
+
+      const Preconfiguration = S.Union([Draft, Published, Archived])
+
+      const repo = yield* makeRepo("Preconfiguration", Preconfiguration, {})
+
+      const id1 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf1"),
+        label: S.NonEmptyString50("draft1")
+      })
+      const id2 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf2"),
+        label: S.NonEmptyString50("pub1")
+      })
+      const id3 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf3"),
+        label: S.NonEmptyString50("arch1")
+      })
+
+      const draft = new Draft({ id: id1, name: "my draft" })
+      const published = new Published({ id: id2, name: "my published", publishedAt: "2024-01-01" })
+      const archived = new Archived({ id: id3, name: "my archived", archivedAt: "2024-06-01" })
+
+      yield* repo.saveAndPublish([draft, published, archived])
+
+      // find each by their PreconfigurationId instance
+      const foundDraft = yield* repo.find(id1)
+      expect(Option.isSome(foundDraft)).toBe(true)
+      expect(Option.getOrThrow(foundDraft)._tag).toBe("Draft")
+      expect(Option.getOrThrow(foundDraft).name).toBe("my draft")
+
+      const foundPublished = yield* repo.find(id2)
+      expect(Option.isSome(foundPublished)).toBe(true)
+      expect(Option.getOrThrow(foundPublished)._tag).toBe("Published")
+
+      const foundArchived = yield* repo.find(id3)
+      expect(Option.isSome(foundArchived)).toBe(true)
+      expect(Option.getOrThrow(foundArchived)._tag).toBe("Archived")
+
+      // not found
+      const notFound = yield* repo.find(
+        new PreconfigurationId({
+          configuratorId: S.NonEmptyString255("nope"),
+          label: S.NonEmptyString50("nope")
+        })
+      )
+      expect(Option.isNone(notFound)).toBe(true)
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("refine union with nested union", () =>
   Effect
@@ -1095,4 +1916,521 @@ it("refine union with nested union", () =>
         })[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+// ---------------------------------------------------------------------------
+// memFilter: computed projection execution (in-memory) and code filter coverage
+// ---------------------------------------------------------------------------
+
+const computedBaseSchema = S.Struct({
+  id: S.String,
+  status: S.Literals(["active", "archived"]),
+  items: S.Array(S.Struct({
+    id: S.String,
+    tag: S.Literals(["a", "b", "c"]),
+    qty: S.Finite,
+    note: S.String
+  }))
+})
+type ComputedBase = S.Codec.Encoded<typeof computedBaseSchema>
+
+const computedRows: ComputedBase[] = [
+  {
+    id: "r1",
+    status: "active",
+    items: [
+      { id: "i1", tag: "a", qty: 10, note: "alpha" },
+      { id: "i2", tag: "a", qty: 20, note: "alpha" },
+      { id: "i3", tag: "b", qty: 5, note: "beta" }
+    ]
+  },
+  { id: "r2", status: "active", items: [] },
+  {
+    id: "r3",
+    status: "archived",
+    items: [
+      { id: "i4", tag: "b", qty: 7, note: "gamma" },
+      { id: "i5", tag: "b", qty: 7, note: "gamma" },
+      { id: "i6", tag: "c", qty: 3, note: "delta" }
+    ]
+  }
+]
+
+it("memFilter: relation-count with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String, aCount: S.NonNegativeInt }),
+      computed({
+        aCount: relation<ComputedBase>("items").count(where("tag", "a"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", aCount: 2 },
+    { id: "r2", aCount: 0 },
+    { id: "r3", aCount: 0 }
+  ])
+})
+
+it("memFilter: relation-any / every with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        hasA: S.Boolean,
+        allB: S.Boolean
+      }),
+      computed({
+        hasA: relation<ComputedBase>("items").any(where("tag", "a")),
+        allB: relation<ComputedBase>("items").every(where("tag", "b"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", hasA: true, allB: false },
+    // empty array: any → false, every → true (JS Array.every on [] is true)
+    { id: "r2", hasA: false, allB: true },
+    { id: "r3", hasA: false, allB: false }
+  ])
+})
+
+it("memFilter: relation-distinct-count with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String, distinctNotes: S.NonNegativeInt }),
+      computed({
+        distinctNotes: relation<ComputedBase>("items").distinctCount("note", where("tag", "neq", "c"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", distinctNotes: 2 }, // alpha, beta
+    { id: "r2", distinctNotes: 0 },
+    { id: "r3", distinctNotes: 1 } // gamma (delta filtered out)
+  ])
+})
+
+it("memFilter: relation-sum with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String, totalQty: S.Finite }),
+      computed({
+        totalQty: relation<ComputedBase>("items").sum("qty", where("tag", "neq", "c"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", totalQty: 35 },
+    { id: "r2", totalQty: 0 },
+    { id: "r3", totalQty: 14 }
+  ])
+})
+
+it("memFilter: relation-collect / collectDistinct with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        notes: S.Array(S.String),
+        distinctNotes: S.Array(S.String)
+      }),
+      computed({
+        notes: relation<ComputedBase>("items").collect("note", where("tag", "neq", "c")),
+        distinctNotes: relation<ComputedBase>("items").collectDistinct("note", where("tag", "neq", "c"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", notes: ["alpha", "alpha", "beta"], distinctNotes: ["alpha", "beta"] },
+    { id: "r2", notes: [], distinctNotes: [] },
+    { id: "r3", notes: ["gamma", "gamma"], distinctNotes: ["gamma"] }
+  ])
+})
+
+it("memFilter: computed projection with multi-statement relation filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String, hits: S.NonNegativeInt }),
+      computed({
+        hits: relation<ComputedBase>("items").count(
+          flow(
+            where("tag", "a"),
+            and("qty", "gt", 10)
+          )
+        )
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", hits: 1 }, // only i2 (a, qty 20)
+    { id: "r2", hits: 0 },
+    { id: "r3", hits: 0 }
+  ])
+})
+
+it("memFilter: relation-sum-expr / sum-expr-by / sum-expr-normalized", () => {
+  const schema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      weight: S.Finite,
+      tradeUnit: S.Struct({ amount: S.Finite, unit: S.String })
+    }))
+  })
+  type Row = S.Codec.Encoded<typeof schema>
+  const rows: Row[] = [
+    {
+      id: "r1",
+      items: [
+        { weight: 2, tradeUnit: { amount: 5, unit: "kg" } },
+        { weight: 4, tradeUnit: { amount: 1000, unit: "g" } },
+        { weight: 3, tradeUnit: { amount: 1, unit: "kg" } }
+      ]
+    },
+    { id: "r2", items: [] }
+  ]
+  const weighted = expr.mul(expr.field("weight"), expr.field("tradeUnit.amount"))
+  const q = make<Row>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        totalRaw: S.Finite,
+        totalsByUnit: S.Array(S.Struct({ unit: S.String, total: S.Finite })),
+        totalKg: S.Finite
+      }),
+      computed({
+        totalRaw: relation<Row>("items").sumExpr(weighted, where("weight", "gte", 0)),
+        totalsByUnit: relation<Row>("items").sumExprBy(weighted, { unit: "tradeUnit.unit" }, where("weight", "gte", 0)),
+        totalKg: relation<Row>("items").sumExprNormalized(weighted, {
+          unit: "tradeUnit.unit",
+          toBase: "kg",
+          factors: { g: 0.001 }
+        }, where("weight", "gte", 0))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, schema))(rows)).toEqual([
+    {
+      id: "r1",
+      totalRaw: 4013,
+      totalsByUnit: [{ unit: "kg", total: 13 }, { unit: "g", total: 4000 }],
+      totalKg: 17
+    },
+    { id: "r2", totalRaw: 0, totalsByUnit: [], totalKg: 0 }
+  ])
+})
+
+it("memFilter: computed projection combined with root where filter", () => {
+  const q = make<ComputedBase>().pipe(
+    where("id", "neq", "r3"),
+    projectComputed(
+      S.Struct({ id: S.String, totalQty: S.Finite }),
+      computed({
+        totalQty: relation<ComputedBase>("items").sum("qty", where("tag", "neq", "c"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", totalQty: 35 },
+    { id: "r2", totalQty: 0 }
+  ])
+})
+
+it("memFilter: computed projection with order/limit/skip applied to base rows", () => {
+  const q = make<ComputedBase>().pipe(
+    order("id", "DESC"),
+    page({ skip: 1, take: 1 }),
+    projectComputed(
+      S.Struct({ id: S.String, total: S.NonNegativeInt }),
+      computed({
+        total: relation<ComputedBase>("items").count(where("qty", "gte", 0))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r2", total: 0 }
+  ])
+})
+
+it("memFilter: computed projection - relation missing on row returns empty value", () => {
+  const partial: ComputedBase[] = [
+    { id: "x1" } as ComputedBase,
+    { id: "x2", status: "active", items: undefined as unknown as ComputedBase["items"] }
+  ]
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        c: S.NonNegativeInt,
+        s: S.Finite,
+        any_: S.Boolean,
+        every_: S.Boolean,
+        coll: S.Array(S.String)
+      }),
+      computed({
+        c: relation<ComputedBase>("items").count(where("tag", "a")),
+        s: relation<ComputedBase>("items").sum("qty", where("tag", "a")),
+        any_: relation<ComputedBase>("items").any(where("tag", "a")),
+        every_: relation<ComputedBase>("items").every(where("tag", "a")),
+        coll: relation<ComputedBase>("items").collect("note", where("tag", "a"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(partial)).toEqual([
+    { id: "x1", c: 0, s: 0, any_: false, every_: true, coll: [] },
+    { id: "x2", c: 0, s: 0, any_: false, every_: true, coll: [] }
+  ])
+})
+
+it("memFilter: rejects extra computed keys not in projection schema", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String }),
+      // @ts-expect-error extra computed keys are rejected statically; keep runtime guard covered
+      computed({
+        bogus: relation<ComputedBase>("items").count(where("tag", "a"))
+      })
+    )
+  )
+  expect(() => toFilter(q, computedBaseSchema)).toThrowError(
+    "Computed projection keys must exist in projection schema"
+  )
+})
+
+// ---------------------------------------------------------------------------
+// memFilter: code filter (where/and/or/scopes) execution coverage
+// ---------------------------------------------------------------------------
+
+type CFRow = {
+  readonly id: string
+  readonly tag: "x" | "y" | "z"
+  readonly qty: number
+  readonly desc: string
+  readonly tags: ReadonlyArray<string>
+  readonly nested: { readonly kind: "k1" | "k2"; readonly v: number }
+}
+
+const cfRows: CFRow[] = [
+  { id: "1", tag: "x", qty: 10, desc: "Hello World", tags: ["red", "green"], nested: { kind: "k1", v: 1 } },
+  { id: "2", tag: "y", qty: 20, desc: "Goodbye", tags: ["blue"], nested: { kind: "k2", v: 5 } },
+  { id: "3", tag: "z", qty: 0, desc: "Hello again", tags: ["red", "blue", "green"], nested: { kind: "k1", v: 9 } },
+  { id: "4", tag: "y", qty: 30, desc: "World cup", tags: [], nested: { kind: "k2", v: 0 } }
+]
+
+const runCF = (q: any) => (memFilter(toFilter(q))(cfRows) as unknown as readonly CFRow[]).map((_) => _.id)
+
+it("codeFilter: where + and chain", () => {
+  const q = make<CFRow>().pipe(
+    where("tag", "y"),
+    and("qty", "gt", 25)
+  )
+  expect(runCF(q)).toEqual(["4"])
+})
+
+it("codeFilter: where + or chain", () => {
+  const q = make<CFRow>().pipe(
+    where("tag", "x"),
+    or("tag", "z")
+  )
+  expect(runCF(q).sort()).toEqual(["1", "3"])
+})
+
+it("codeFilter: nested scope precedence (a AND (b OR c))", () => {
+  const q = make<CFRow>().pipe(
+    where("tag", "y"),
+    and(
+      where("qty", "gt", 25),
+      or("desc", "contains", "good")
+    )
+  )
+  // tag=y AND (qty>25 OR desc contains "good") → row 2 (Goodbye) and row 4 (qty 30)
+  expect(runCF(q).sort()).toEqual(["2", "4"])
+})
+
+it("codeFilter: contains/startsWith/endsWith are case-insensitive", () => {
+  expect(runCF(make<CFRow>().pipe(where("desc", "contains", "WORLD"))).sort()).toEqual(["1", "4"])
+  expect(runCF(make<CFRow>().pipe(where("desc", "startsWith", "hello"))).sort()).toEqual(["1", "3"])
+  expect(runCF(make<CFRow>().pipe(where("desc", "endsWith", "AGAIN")))).toEqual(["3"])
+})
+
+it("codeFilter: array includes / includes-any / includes-all", () => {
+  expect(runCF(make<CFRow>().pipe(where("tags", "includes", "red"))).sort()).toEqual(["1", "3"])
+  expect(runCF(make<CFRow>().pipe(where("tags", "includes-any", ["blue", "green"]))).sort()).toEqual([
+    "1",
+    "2",
+    "3"
+  ])
+  expect(runCF(make<CFRow>().pipe(where("tags", "includes-all", ["red", "blue"])))).toEqual(["3"])
+})
+
+it("codeFilter: Date array / Set includes and in", () => {
+  const d0 = new Date("2020-01-01T00:00:00.000Z")
+  const d1 = new Date("2021-01-01T00:00:00.000Z")
+  type DateRow = {
+    readonly id: string
+    readonly dates: Date[]
+    readonly dateSet: ReadonlySet<Date>
+    readonly tag: string
+  }
+  const rows: DateRow[] = [
+    { id: "1", dates: [d0], dateSet: new Set([d0]), tag: "a" },
+    { id: "2", dates: [d1, d0], dateSet: new Set([d1]), tag: "b" }
+  ]
+  const run = (q: any) => (memFilter(toFilter(q))(rows) as DateRow[]).map((_) => _.id)
+  expect(run(make<DateRow>().pipe(where("dates", "includes", d0))).sort()).toEqual(["1", "2"])
+  expect(run(make<DateRow>().pipe(where("dates", "includes", d1)))).toEqual(["2"])
+  expect(run(make<DateRow>().pipe(where("dateSet", "includes", d0)))).toEqual(["1"])
+  expect(run(make<DateRow>().pipe(where("dates", "includes-any", [d1])))).toEqual(["2"])
+  expect(run(make<DateRow>().pipe(where("dateSet", "includes-any", new Set([d0, d1])))).sort()).toEqual([
+    "1",
+    "2"
+  ])
+  expect(run(make<DateRow>().pipe(where("tag", "in", new Set(["a"]))))).toEqual(["1"])
+})
+
+it("codeFilter: Map hasKey / hasValue / hasKeyValue", () => {
+  type MapRow = {
+    readonly id: string
+    readonly meta: ReadonlyMap<string, number>
+  }
+  const rows: MapRow[] = [
+    { id: "1", meta: new Map([["n", 1], ["x", 2]]) },
+    { id: "2", meta: new Map([["n", 9]]) },
+    { id: "3", meta: new Map([["z", 2]]) }
+  ]
+  const run = (q: any) => (memFilter(toFilter(q))(rows) as MapRow[]).map((_) => _.id)
+  expect(run(make<MapRow>().pipe(where("meta", "hasKey", "n"))).sort()).toEqual(["1", "2"])
+  expect(run(make<MapRow>().pipe(where("meta", "notHasKey", "n")))).toEqual(["3"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasValue", 2))).sort()).toEqual(["1", "3"])
+  expect(run(make<MapRow>().pipe(where("meta", "notHasValue", 2)))).toEqual(["2"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKeyValue", ["n", 1])))).toEqual(["1"])
+  expect(run(make<MapRow>().pipe(where("meta", "notHasKeyValue", ["n", 1]))).sort()).toEqual(["2", "3"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKey-any", ["z", "missing"])))).toEqual(["3"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKey-all", ["n", "x"])))).toEqual(["1"])
+  expect(run(make<MapRow>().pipe(where("meta", "notHasKey-all", ["n", "x"]))).sort()).toEqual(["2", "3"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasValue-any", [9, 99])))).toEqual(["2"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasValue-all", [1, 2])))).toEqual(["1"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKeyValue-any", [["n", 9], ["missing", 0]])))).toEqual(["2"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKeyValue-all", [["n", 1], ["x", 2]])))).toEqual(["1"])
+})
+
+it("codeFilter: in / notIn", () => {
+  expect(runCF(make<CFRow>().pipe(where("tag", "in", ["x", "z"]))).sort()).toEqual(["1", "3"])
+  expect(runCF(make<CFRow>().pipe(where("tag", "notIn", ["x", "z"]))).sort()).toEqual(["2", "4"])
+})
+
+it("codeFilter: gt / gte / lt / lte / neq", () => {
+  expect(runCF(make<CFRow>().pipe(where("qty", "gt", 10))).sort()).toEqual(["2", "4"])
+  expect(runCF(make<CFRow>().pipe(where("qty", "gte", 10))).sort()).toEqual(["1", "2", "4"])
+  expect(runCF(make<CFRow>().pipe(where("qty", "lt", 10)))).toEqual(["3"])
+  expect(runCF(make<CFRow>().pipe(where("qty", "lte", 10))).sort()).toEqual(["1", "3"])
+  expect(runCF(make<CFRow>().pipe(where("qty", "neq", 0))).sort()).toEqual(["1", "2", "4"])
+})
+
+it("codeFilter: nested path access through dot notation", () => {
+  expect(runCF(make<CFRow>().pipe(where("nested.kind", "k1"))).sort()).toEqual(["1", "3"])
+  expect(
+    runCF(
+      make<CFRow>().pipe(
+        where("nested.kind", "k2"),
+        and("nested.v", "gt", 0)
+      )
+    )
+  )
+    .toEqual(["2"])
+})
+
+it("codeFilter: array length predicates", () => {
+  expect(runCF(make<CFRow>().pipe(where("tags.length", 0)))).toEqual(["4"])
+  expect(runCF(make<CFRow>().pipe(where("tags.length", "gte", 2))).sort()).toEqual(["1", "3"])
+})
+
+it("codeFilter: order + skip + limit applied after filter", () => {
+  const q = make<CFRow>().pipe(
+    where("tag", "neq", "z"),
+    order("qty", "DESC"),
+    page({ skip: 1, take: 2 })
+  )
+  expect(runCF(q)).toEqual(["2", "1"])
+})
+
+// ─────────────────────────────────────────────────────────────────────────────
+// memFilter: aggregate (GROUP BY) support
+// ─────────────────────────────────────────────────────────────────────────────
+
+it("memFilter: agg-count-when groups rows and counts conditionally", () => {
+  type Row = { city: string; status: string }
+  const rows: Row[] = [
+    { city: "NYC", status: "active" },
+    { city: "NYC", status: "inactive" },
+    { city: "NYC", status: "active" },
+    { city: "LA", status: "active" }
+  ]
+  const result = memFilter<Row>({
+    t: {} as Row,
+    select: [
+      { key: "city", path: "city" },
+      {
+        key: "activeCount",
+        aggregate: {
+          _tag: "agg-count-when",
+          filter: [{ t: "where", path: "status", op: "eq", value: "active" }]
+        }
+      },
+      { key: "total", aggregate: { _tag: "agg-count" } }
+    ] as any
+  })(rows) as any[]
+
+  expect(result.length).toBe(2)
+  const nyc = result.find((r: any) => r.city === "NYC")!
+  expect(nyc.activeCount).toBe(2)
+  expect(nyc.total).toBe(3)
+  const la = result.find((r: any) => r.city === "LA")!
+  expect(la.activeCount).toBe(1)
+  expect(la.total).toBe(1)
+})
+
+it("memFilter: agg-sum / agg-min / agg-max aggregate numerics", () => {
+  type Row = { dept: string; salary: number }
+  const rows: Row[] = [
+    { dept: "eng", salary: 100 },
+    { dept: "eng", salary: 200 },
+    { dept: "hr", salary: 50 }
+  ]
+  const result = memFilter<Row>({
+    t: {} as Row,
+    select: [
+      { key: "dept", path: "dept" },
+      { key: "total", aggregate: { _tag: "agg-sum", field: "salary" } },
+      { key: "min", aggregate: { _tag: "agg-min", field: "salary" } },
+      { key: "max", aggregate: { _tag: "agg-max", field: "salary" } }
+    ] as any
+  })(rows) as any[]
+
+  expect(result.length).toBe(2)
+  const eng = result.find((r: any) => r.dept === "eng")!
+  expect(eng.total).toBe(300)
+  expect(eng.min).toBe(100)
+  expect(eng.max).toBe(200)
+  const hr = result.find((r: any) => r.dept === "hr")!
+  expect(hr.total).toBe(50)
+})
+
+it("memFilter: aggregate with nested path grouping", () => {
+  type Row = { address: { city: string }; value: number }
+  const rows: Row[] = [
+    { address: { city: "NYC" }, value: 10 },
+    { address: { city: "NYC" }, value: 20 },
+    { address: { city: "LA" }, value: 5 }
+  ]
+  const result = memFilter<Row>({
+    t: {} as Row,
+    select: [
+      { key: "city", path: "address.city" },
+      { key: "count", aggregate: { _tag: "agg-count" } }
+    ] as any
+  })(rows) as any[]
+
+  expect(result.length).toBe(2)
+  expect(result.find((r: any) => r.city === "NYC")!.count).toBe(2)
+  expect(result.find((r: any) => r.city === "LA")!.count).toBe(1)
+})