docs(sql-orm-many-to-many): slice 2 spec + plan (TML-2786)

Filter slice: some/every/none EXISTS through the junction. 2 dispatches
(filter code / integration tests). Reuses slice 1 User↔Tag fixture.

Signed-off-by: Alexey Orlenko's AI Agent <robot@aqrln.net>

Author: tensordreams

projects/sql-orm-many-to-many/slices/02-filter-exists-through-junction/plan.md

@@ -0,0 +1,24 @@
+# Slice 2: filter EXISTS through the junction — Dispatch plan
+
+**Spec:** `projects/sql-orm-many-to-many/slices/02-filter-exists-through-junction/spec.md`
+**Linear:** [TML-2786](https://linear.app/prisma-company/issue/TML-2786)
+
+Two dispatches: filter code (judgment) then integration tests (verification). No fixture dispatch — slice 1's `User ↔ Tag` is reused.
+
+### Dispatch 1: filter EXISTS walks the junction
+
+- **Outcome:** `some`/`every`/`none` on an M:N relation compile to a correctly-shaped EXISTS / NOT EXISTS that walks the junction (target JOIN junction correlated to parent on the junction side; composite-key AND-ed); FK filters unchanged. Unit-tested at the AST level.
+- **Builds on:** slice 0's `ResolvedRelation.through` (carried by `resolveModelRelations`).
+- **Hands to:** correctly-shaped M:N relation filters — the behaviour D2 verifies on the DB.
+- **Focus:** the M:N branch in `buildExistsExpr`/`buildJoinWhere` (`model-accessor.ts`); surface `through` onto the filter relation if it's dropped; unit tests for the EXISTS AST (some/every/none through junction). No integration tests here.
+
+### Dispatch 2: filter integration tests (operator standard)
+
+- **Outcome:** integration tests prove `.filter(u => u.tags.some/every/none(...))` returns the right users on PGlite, following the standard — whole-row `toEqual` on the filtered set, explicit `.select` in most, **≥1** implicit/default-selection case; `some`, `every`, `none`, and an empty-match edge covered.
+- **Builds on:** D1's filter code + slice 1's fixture/seed helpers (`seedUserTags`).
+- **Hands to:** the slice-DoD-satisfying M:N filter coverage.
+- **Focus:** new integration test file under `test/integration/test/sql-orm-client/`, PGlite via `withCollectionRuntime`; reuse the `seedTags`/`seedUserTags` helpers slice 1 added. Run via `cd test/integration && pnpm test test/sql-orm-client/<file>`.
+
+## Handoff completeness
+
+Slice-DoD reachable: correctly-shaped junction EXISTS (D1 unit) + filter behaviour on DB per standard (D2 integration) + FK filters unchanged (D1).

projects/sql-orm-many-to-many/slices/02-filter-exists-through-junction/spec.md

@@ -0,0 +1,53 @@
+# Slice 2: relation filters (some/every/none) through the junction
+
+_Parent project: `projects/sql-orm-many-to-many/`. Outcome: `.filter(u => u.tags.some/every/none(...))` emits an EXISTS that walks the junction._
+
+## At a glance
+
+`db.orm.User.filter((u) => u.tags.some((t) => t.name.eq('x')))` (and `.every` / `.none`) must produce an EXISTS subquery that walks the **junction** for M:N relations. Today `buildJoinWhere` (`model-accessor.ts`) reads only `relation.on.localFields/targetFields`, so an M:N filter would emit a wrong-shape EXISTS that skips the junction. This slice adds the junction hop, reusing slice 0's `through` descriptor.
+
+## Chosen design
+
+**Add an M:N branch to the EXISTS builder.** `createRelationFilterAccessor` → `buildExistsExpr` → `buildJoinWhere` (`model-accessor.ts`). When the resolved relation carries `through`:
+
+- **`some(pred)`** → `EXISTS (SELECT 1 FROM target JOIN junction ON junction.childColumns = target.targetColumns WHERE junction.parentColumns = parent.anchor AND <pred>)`.
+- **`none(pred)`** → `NOT EXISTS (… AND <pred>)`.
+- **`every(pred)`** → `NOT EXISTS (… AND NOT (<pred>))` (no related row that fails the predicate), mirroring the existing FK `every` shape.
+
+The parent correlation moves to the **junction** side (`junction.parentColumns = parent.anchor`); the target is reached via the junction join (`junction.childColumns = target.targetColumns`); composite keys AND-ed. The child predicate (`<pred>`) is unchanged — it still applies to the target columns.
+
+The relation passed to `buildJoinWhere` comes from `resolveModelRelations`, which slice 0 extended with `through`; **confirm** the filter path's relation type carries `through` (if it uses a relation shape that drops it, plumb it through — same one-field surfacing slice 1 did for `IncludeExpr`).
+
+## Coherence rationale
+
+One reviewable story: "M:N relation filters walk the junction." The `some`/`every`/`none` cases share the single junction-EXISTS shape; they're one coherent change to `buildJoinWhere`/`buildExistsExpr`, not separable.
+
+## Scope
+
+**In:** the M:N branch in `buildExistsExpr`/`buildJoinWhere` (`model-accessor.ts`) for `some`/`every`/`none`; surfacing `through` onto the filter path's relation if needed; unit tests (EXISTS AST through junction); integration tests per the standard.
+
+**Out:** include reads (slice 1, done); nested writes (slice 3); non-relation filters; any `through` shape change (slice 0 owns it). No fixture change — reuse slice 1's `User ↔ Tag`.
+
+## Pre-investigated edge cases
+
+| Edge case | Disposition | Notes |
+|---|---|---|
+| Composite-key junction | AND across all column pairs in both the junction→parent correlation and junction→target join | slice 0 arrays |
+| `every` semantics | `NOT EXISTS (… junction … AND NOT(pred))` — mirror the existing FK `every`, just through the junction | don't invent a new shape |
+| Relation type may drop `through` | If the filter path's resolved-relation type doesn't carry `through`, surface/plumb it (one field), don't approximate | grounding for the implementer |
+
+## Slice-specific done conditions
+
+- [ ] `.some/.every/.none` on an M:N relation emit a correctly-shaped EXISTS/NOT EXISTS that joins through the junction (composite-key AND-ed); unit test asserts the AST.
+- [ ] Integration tests (PGlite) per the standard: whole-row `toEqual` on the filtered result set; explicit `.select` in most; **≥1** implicit/default-selection case; cover `some`, `every`, `none`, and an empty-match edge.
+- [ ] FK relation filters unchanged (existing tests pass).
+
+## Open Questions
+
+1. **`through` availability on the filter relation.** Working position: `resolveModelRelations` already carries `through` (slice 0); the filter path reuses it directly. If grounding shows otherwise, plumb the one field (no design change).
+
+## References
+
+- Parent project: `projects/sql-orm-many-to-many/spec.md` (§ Cross-cutting — integration-test standard).
+- Slice 0 `ResolvedRelation.through`; slice 1 fixture (`User ↔ Tag`).
+- Linear: [TML-2786](https://linear.app/prisma-company/issue/TML-2786)

projects/sql-orm-many-to-many/trace.jsonl

@@ -46,3 +46,5 @@
 {"event_id":"b5530bd5-2ada-44bc-b65e-880aaff74187","schema_version":"1","ts":"2026-06-01T18:53:04.232Z","project_run_id":"sql-orm-many-to-many","orchestrator_agent_id":null,"event_type":"brief-issued","dispatch_id":"88c9c264-8edc-4584-b440-7d51eeae37e4","round_id":"a405f9a4-2407-4328-93f9-476c31d88c0e","brief_byte_length":4062,"brief_content_hash":"c0f7aa67226f403d7c10b578156ae5b5dd8141de924ed80e3b0e1aeec917ae3e","brief_disposition":"initial"}
 {"event_id":"7f4f9ac3-eaf8-41df-b5df-cc72314030de","schema_version":"1","ts":"2026-06-01T19:14:43.687Z","project_run_id":"sql-orm-many-to-many","orchestrator_agent_id":null,"event_type":"round-end","dispatch_id":"88c9c264-8edc-4584-b440-7d51eeae37e4","round_id":"a405f9a4-2407-4328-93f9-476c31d88c0e","verdict":"satisfied","findings_filed":0,"wall_clock_ms":1299311}
 {"event_id":"10edc1f4-e070-4dc6-b0ac-bf8eaf2565a7","schema_version":"1","ts":"2026-06-01T19:14:44.090Z","project_run_id":"sql-orm-many-to-many","orchestrator_agent_id":null,"event_type":"dispatch-end","dispatch_id":"88c9c264-8edc-4584-b440-7d51eeae37e4","result":"completed","wall_clock_ms":1299697}
+{"event_id":"c766ebb8-dfa9-4f3a-b033-3ce51a3594cc","schema_version":"1","ts":"2026-06-01T19:18:04.849Z","project_run_id":"sql-orm-many-to-many","orchestrator_agent_id":null,"event_type":"spec-authored","spec_path":"projects/sql-orm-many-to-many/slices/02-filter-exists-through-junction/spec.md","spec_kind":"slice","byte_length":4110,"edge_cases_count":3,"open_questions_count":1,"dod_items_count":3}
+{"event_id":"c358128a-8d02-451d-b2d6-ee791793231e","schema_version":"1","ts":"2026-06-01T19:18:05.325Z","project_run_id":"sql-orm-many-to-many","orchestrator_agent_id":null,"event_type":"plan-authored","plan_path":"projects/sql-orm-many-to-many/slices/02-filter-exists-through-junction/plan.md","plan_kind":"slice","byte_length":2068,"dispatch_count":2,"slice_count":null,"dispatch_size_distribution":{"S":0,"M":2,"L":0,"XL":0},"open_items_count":0}