measure: how each driver answers the six non-JSON comparand types (#7872 restart condition b)

[huangyiirene]

What this card is

A measurement, not a fix. Its whole deliverable is a table plus a judgement about what the table means. No behaviour changes, no refusal is added, no schema is touched.

It exists because triage named this measurement as restart condition (b) on #7872 (comment 5263919935), in those words: 「the still-unmeasured four-driver divergence matrix (crash/refuse/silent-empty on the six comparands), which now answers "how much silent divergence exists under the unenforced schema" and would feed either outcome.」

"Either outcome" is the point: the drivers seat measured (#7872 comment 5261540941) that comparand-type policy is per-driver by construction — every driver calls parseFilterAST, which casts object-form filters through unvalidated, and NormalizedFilterSchema (which does carry type policy for $gt/$between/$contains) has zero consumers outside packages/spec. Whether the spec seat builds a door (#6017, declaration 5261543992) or declines it, the same question has to be answered first: how far apart are the five drivers today? If they already agree, a door is codifying consensus. If they disagree, the divergence is itself the argument.

The measurement

Six comparand types, from #7872's measured table on driver-memory:

BigInt(100) · () => 1 · Symbol('x') · new Map() · a class instance · undefined

For each, on each driver, in a scalar comparison ({qty: {$eq: <value>}} is the shape #7872 used; extend to a second operator only if it changes the answer). Record which of these happens:

• crash — an unhandled throw reaches the caller (record the error, and whose it is: the driver's, or a third party's like mingo/knex)
• refuse — a clean typed refusal (record the code, and whether it carries an ADR-0112 envelope)
• silent-empty — 0 rows, no error (the { field: {} }(零个操作符的字段约束)在同仓有三个答案:driver-sql 组合子内 TRUE、顶层抛 INVALID_FILTER、formula/driver-memory FALSE #5240 shape)
• works — rows come back as if the comparand were a normal literal (record what it matched)

Five drivers: driver-memory, driver-sql, driver-sqlite-wasm, driver-turso, driver-mongodb. Include driver-memory rather than copying #7872's numbers — re-measuring it on current main confirms or corrects the card that started this.

Environment constraints — declare what you could not reach

Known before you start, from the drivers seat's operating notes:

• mongodb-memory-server's binary download is blocked by the proxy (403) in this environment. driver-mongodb has to be measured server-free at the translation layer (what the filter lowers to, and whether the lowering throws) rather than by executing against a real mongod. That is a real answer to a slightly different question — say so explicitly in the row rather than implying an execution result.
• driver-sql (better-sqlite3, :memory:) and driver-sqlite-wasm run in-process.
• driver-turso has local / replica / remote transports that do not behave alike (TursoDriver remote 面根本不生成自增号:RemoteTransport.create 自建 INSERT,auto_number 只是个 TEXT 列 #6944 is the precedent: the remote transport bypasses paths the other two take). Measure what you can reach without a real Turso endpoint and say which transports the result covers.

A row you could not measure is a legitimate result. Write "not reachable in this environment, because X" — do not infer it from a sibling driver and do not leave it blank.

Deliverable

A report on this card and a copy of the matrix as a comment on #7872, since that is the card whose restart condition this satisfies. Plus a short judgement: is the divergence material? Name the worst cell and say why it is the worst — "five drivers answer the same wrong thing" and "five drivers answer five different things" have opposite implications for whether a shared door is worth building.

Explicitly out of scope

• ⛔ No fix, on any driver. driver-memory has no policy for an unsupported comparand TYPE: a BigInt crashes with a raw mingo TypeError, and four other types silently answer zero rows #7872 is held; this card does not lift that hold, it feeds it.
• ⛔ No new conformance cells and no ledger entries. check:driver-conformance currently reads 40 covered / 0 DEBT / 0 exempt — cleared this week. Adding cells for driver-memory / driver-mongodb would be capability investment in drivers whose investment is frozen under [裁决] driver-memory / driver-mongodb 投入冻结 —— 维护者 2026-08-05 口径（跨单锚点） #5499 (maintainer, restated 2026-08-12 on driver-memory 完全没有行级租户隔离(#3724 的未修姊妹面):多租户下静默不隔离 #6915). If you believe a pin is warranted so the matrix cannot drift silently, propose it in the report with the reason; do not add it.
• ⛔ Nothing in packages/spec. The door question belongs to the spec seat ([PM seat] domain:spec — 🟢 os-zhuang (standby: 0 in flight, queue empty) #6017).

Refs

#7872 (the finding and restart condition b) · #6017 (5261543992, the cross-seat declaration) · #7596 (why $eq/$in are deliberately z.any()) · #5240 (the silent-empty shape) · #5499 (the investment freeze and its scope)

[huangyiirene]

Claimed by the drivers seat — PM session session_013ZU38vNzLXCscgdFZjKd53, dev branch claude/issue-7956-comparand-type-divergence-matrix.

Filed and claimed by the seat rather than routed through triage, for the same reason recorded on #7853: the triage Routine has not reached it (it did not exist an hour ago), the lane is at zero in-flight with an empty pm:queue, and the card is a measurement inside this seat's own file surface. The two checks triage would have made:

• Dedup: driver-memory has no policy for an unsupported comparand TYPE: a BigInt crashes with a raw mingo TypeError, and four other types silently answer zero rows #7872 is the finding this feeds and explicitly does not cover the measurement (its own restart condition (b) names it as outstanding). $regex on driver-sql is not a regex — it compiles to a substring LIKE, so it both over-matches and silently matches nothing #4706 is a different axis ($regex semantics on driver-sql). Nothing else open measures comparand types across drivers.
• Grade: S/M, domain:drivers. Bounded by construction — six values × five drivers, deliverable is a table and a judgement, zero production files touched.

Why this is dispatchable while #7872 is held. The hold is on the fix — which route closes the gap, and whether a spec-side door gets built. This card changes nothing and decides nothing; it produces the input triage itself asked for. It is also outside #5499's reach for the same reason route B passed on #6915: measuring a driver is not investing in it.

What the seat is deliberately not pre-judging: whether the divergence is material. The dispatch asks for that judgement with the worst cell named, because "all five answer the same wrong thing" and "all five answer differently" argue in opposite directions about a shared door — and this seat would rather read the measurement than confirm its own guess.

---

Generated by Claude Code

[huangyiirene]

Measured on origin/main @ a44d1b4, in-process, dedicated worktree. Fixture is identical everywhere: one row { id: '1', qty: 100 }, qty declared number (SQL family: integer). Control ({qty: {$eq: 100}}) returns that one row on every executable driver, so a 0 below is a real answer and not a broken fixture.

Diff is empty. The probe harness was five throwaway *.test.ts files, one per driver package, deleted after the run; git status is clean, no changeset, no PR. check:driver-conformance still reads 40 covered / 0 DEBT / 0 exempt (re-run after the measurement, output below).

---

The matrix — { qty: { $eq: <value> } }

Verdict vocabulary as the card defines it. refuse everywhere below means the full ADR-0112 envelope: code: 'INVALID_FILTER', status: 400, message naming the field, the operator and the offending type.

comparand	driver-memory	driver-sql	driver-sqlite-wasm	driver-turso local	driver-turso remote	driver-mongodb
BigInt(100)	crash	works (1 row)	works (1 row)	works (1 row)	works (binds)	works (int64) ᶦ
() => 1	silent-empty	refuse	refuse	refuse	refuse	silent-mutate
Symbol('x')	silent-empty	refuse	refuse	refuse	refuse	silent-mutate
new Map()	silent-empty	refuse	refuse	refuse	refuse	silent-empty ᶦ
class instance	silent-empty	refuse	refuse	refuse	refuse	silent-empty ᶦ
undefined	silent-empty	refuse	refuse	refuse	refuse	silent-mutate

ᶦ = inferred, not executed — see the driver-mongodb row declaration below. Everything unmarked was executed and the row count observed.

Evidence per column

driver-memory — reproduces #7872 exactly, on both faces, unchanged by #7723 / #7852 / #7869.

MEM find  $eq | BigInt(100) -> CRASH (no envelope) | TypeError: Do not know how to serialize a BigInt | at JSON.stringify (<anonymous>)
MEM query $eq | BigInt(100) -> CRASH (no envelope) | TypeError: Do not know how to serialize a BigInt | at JSON.stringify (<anonymous>)
MEM find  $eq | () => 1     -> SILENT-EMPTY (0 rows, no error)   [same for Symbol, Map, class instance, undefined]

Third party's crash, not the driver's: mingo query.js Query.compile serialising the query object to build its cache key. No envelope, no code, no status. find() and MemoryAnalyticsService.query() are identical, as #7872 said.

driver-sql — five clean refusals, BigInt deliberately accepted. All refusals raised by unsupportedFilterError at packages/drivers/driver-sql/src/sql-driver.ts:554, i.e. before knex or better-sqlite3 ever sees the value:

SQL $eq | () => 1     -> REFUSE code=INVALID_FILTER status=400 | Operator "$eq" on field "qty" requires a single comparable
                         value, but received an object (function), which cannot be bound as a SQL parameter. Use a string,
                         number, boolean, null, Date or binary value; for a list use $in/$nin…
SQL $eq | undefined   -> REFUSE code=INVALID_FILTER status=400 | Comparand at filter.qty.$eq is undefined. @objectstack/spec
                         FieldOperatorsSchema declares no undefined comparand, and in JavaScript { "qty": undefined } cannot
                         be told apart from omitting the key — yet the two mean OPPOSITE…
SQL $eq | BigInt(100) -> WORKS rows=1 [{"id":"1","qty":100}]

driver-sqlite-wasm — not an independent answer. Byte-identical to driver-sql, and the stack frame proves why: every refusal is raised at driver-sql/src/sql-driver.ts:554. SqliteWasmDriver inherits SqlDriver's filter compiler; only the dialect below it differs, and the comparand never reaches the dialect.

driver-turso local — also SqlDriver's compiler (same sql-driver.ts:554 frame; transportMode asserted 'local' in the probe).

driver-turso remote — its own independent implementation, same verdicts. invalidFilterError at packages/drivers/driver-turso/src/remote-transport.ts:536. Measured against a capturing stub client, so for the accepted cells the honest answer is what it lowered to, not a row count:

TURSO-REMOTE $eq | 100         -> LOWERED SELECT * FROM "probe" WHERE "qty" = ?  args=[100]  argTypes=number
TURSO-REMOTE $eq | BigInt(100) -> LOWERED SELECT * FROM "probe" WHERE "qty" = ?  args=[100n] argTypes=bigint
TURSO-REMOTE $eq | () => 1     -> REFUSE code=INVALID_FILTER status=400 | [RemoteTransport] Filter comparand 'probe.qty' $eq
                                  () => 1 is a function, which this transport cannot bind. A comparison value must be a
                                  string, number, bigint, boolean, null or Date. Refusing rather than binding its JSON text…

driver-mongodb — no comparand-type policy at any layer. All six pass through translateFilter untouched — it never throws, and its shape gate (reduceFilterNode) sees a well-formed 'clause' because the operator key is present. find() does exactly two things (mongodb-driver.ts:290-293): translateFilter, then collection.find(filter). So the next and last step is the mongodb package's own BSON encoder, which I ran directly:

comparand	translateFilter emits	BSON.serialize → wire document
BigInt(100)	{qty:{$eq:100n}}	{qty:{$eq:100}} (int64)
() => 1	{qty:{$eq:ƒ}}	{qty:{}} — the operator is deleted
Symbol('x')	{qty:{$eq:Symbol}}	{qty:{}} — the operator is deleted
new Map()	{qty:{$eq:Map{}}}	{qty:{$eq:{}}}
class instance	{qty:{$eq:Thing}}	{qty:{$eq:{"v":100}}}
undefined	{qty:{$eq:undefined}}	{qty:{}} — the operator is deleted

Note what the encoder manufactures: {qty: {}} is the zero-operator field constraint #5240 ruled on and driver-memory refuses by name — produced here from a filter that did carry an operator.

---

Second operator: $in

Worth one column only for driver-mongodb; every other driver answers $in: [V] exactly as $eq: V (memory: crash on BigInt, 0 rows on the rest; SQL family: same refusals, re-worded for the list position — has a value at index 0 of its list that cannot be bound; BigInt still works). Mongo differs because BSON drops array elements rather than the key:

comparand	mongo wire document for {qty:{$in:[V]}}
() => 1 / Symbol('x')	{qty:{$in:[]}} — an empty $in, matches nothing
undefined	{qty:{$in:[null]}} — silently becomes a null comparand
BigInt(100)	{qty:{$in:[100]}}
Map / class instance	{qty:{$in:[{}]}} / {qty:{$in:[{"v":100}]}}

undefined → null is a semantic substitution, not a drop: the caller asked "in [undefined]" and the server is asked "in [null]".

---

Addendum — the implicit-equality form { qty: <value> }, and the worst cell in the report

I measured a third shape because it costs nothing and it is where the failure changes direction. Same six values, no operator:

comparand	driver-memory	SQL family (sql / wasm / turso local)	driver-turso remote	driver-mongodb wire document
BigInt(100)	crash	works (1 row)	binds 100n	{qty:100}
() => 1	silent-empty	refuse (Operator "="…)	refuse	{}
Symbol('x')	silent-empty	refuse	refuse	{}
new Map()	silent-empty	refuse	refuse (compiles to NO predicate)	{qty:{}}
class instance	silent-empty	refuse	refuse (key "v" is not an operator)	{qty:{"v":100}}
undefined	silent-empty	refuse (Comparand at filter.qty is undefined…)	refuse	{}

{} is the empty MongoDB filter. A predicate the caller wrote to constrain the query is encoded onto the wire as no constraint at all — the amplifying direction (fewer constraints ⇒ more rows) that #3948 outlawed and ADR-0078 / #4286 ruled on for having. Every other driver answers those same three filters with either a 400 or zero rows.

Worst cell: driver-mongodb × { qty: undefined } → {} (match everything). Why this one and not the BigInt crash:

• It is the failure that returns more data, not less. Every other cell in this report is a crash, a 400, or 0 rows — all of them safe-by-accident. This one silently widens. On a filtered read that is a wrong answer; on a filter that carries a tenant or RLS predicate alongside, dropping a sibling key is a disclosure shape, not a wrong number.
• undefined is the one value here that arrives by accident. Nobody types Symbol('x') into a filter. { owner: someVar } with someVar unset is a normal afternoon.
• The disagreement on it is maximal and total. The same filter object: driver-sql throws a 400 whose message was written specifically about this value ("in JavaScript { "qty": undefined } cannot be told apart from omitting the key — yet the two mean OPPOSITE things"), driver-memory answers 0 rows, driver-mongodb answers every row in the collection. Three drivers, three opposite answers, no error anywhere on two of them.

Worst cell inside the card's strict {$eq:} matrix: driver-memory × BigInt(100) — still the only raw unhandled third-party TypeError reaching a caller with no envelope, and the cell where the portability claim breaks loudest (the filter that crashes memory returns the row on three other drivers).

---

Unreachable cells, declared

• driver-mongodb, all six: not executed against a real mongod. Verified rather than assumed: curl https://fastdl.mongodb.org/… → curl: (56) CONNECT tunnel failed, response 403; no mongod on PATH; nothing listening on 127.0.0.1:27017; no MONGO* env. So assumption C holds and mongodb-memory-server cannot download its binary here. What I did measure is executed and exact: the document translateFilter emits, and what the mongodb package's own BSON.serialize makes of it — the only two steps find() performs. The row counts in the mongo column are therefore inferred from the wire document plus documented MongoDB semantics ({} matches all; {qty:{}} is equality against the empty document, so 0 rows on a numeric column; a BSON int64 100 compares equal to a stored int32 100 under Mongo's cross-type numeric comparison). Every inferred cell is marked ᶦ. The mutation — that the operator is silently deleted before the wire — is measured, not inferred, and it is the part that matters.
• driver-turso replica transport: not constructed. It needs a real syncUrl endpoint; there is none here. Its reads take SqlDriver's path per the module header at turso-driver.ts:11-12, which is the path I measured through local — but I did not execute replica, so I am not claiming its cells, only saying which code they would run.
• Everything else in the matrix was executed in-process.

---

Assumptions A–D against the measurement

• A — survives, exactly. Re-measured rather than copied, on a44d1b4, after the memory-driver.ts / memory-analytics.ts rewrites (fix(driver-memory): make the $contains family case-exact and answer count_distinct #7723, fix(driver-memory): render the analytics echo as the query it describes (#7117) #7852, fix(driver-memory): render the pipeline dump's RegExp operand instead of dropping it to {} (#7853) #7869): BigInt still a raw mingo TypeError out of Query.compile on both faces, the other five still 0 rows on both. driver-memory has no policy for an unsupported comparand TYPE: a BigInt crashes with a raw mingo TypeError, and four other types silently answer zero rows #7872's table needs no correction.
• B — half survives, and the interesting half fails. Both drivers are measurable in-process ✅. But "knex/sqlite will bind or reject these at a different layer than mingo does" is wrong: neither knex nor sqlite nor the wasm dialect ever sees these values — driver-sql refuses them itself, in its own code, at sql-driver.ts:554, before any binding is attempted. And driver-sqlite-wasm is not a second data point at all: it inherits that exact compiler. The matrix has five driver columns but only three independent implementations (driver-memory/mingo; SqlDriver's compiler serving sql + wasm + turso-local; RemoteTransport), plus driver-mongodb's absence of one. The table should be read with that in mind.
• C — survives, verified not assumed. Evidence above.
• D — does not survive. On this axis Turso's transports agree: local and remote return the same verdict for all six under $eq and $in, from two entirely separate implementations. They differ only in which message the bare form produces (remote decomposes the object as an operator map first, so new Map() is refused as "compiles to NO predicate" and a class instance as key "v" is not an operator) — different words, same refusal, same envelope. TursoDriver remote 面根本不生成自增号:RemoteTransport.create 自建 INSERT,auto_number 只是个 TEXT 列 #6944's precedent does not reproduce here; if anything this is the one place in the matrix where two independent implementations converged without sharing code.

---

Judgement: is the divergence material?

Yes — and the shape of it is neither of the two the dispatch anticipated. It is not "all five answer the same wrong thing" and not "all five answer differently". It is two camps and one hole:

1. The SQL family already has the policy, and wrote it down twice. driver-sql, driver-sqlite-wasm and driver-turso (both transports) refuse all six with the same ADR-0112 INVALID_FILTER/400 envelope and near-identical prose — and they got there through two independent implementations (sql-driver.ts:554, remote-transport.ts:536) that agree on the accepted set down to the wording: "a string, number, bigint, boolean, null or Date".
2. driver-memory and driver-mongodb have no policy at any layer, and cannot easily grow one, because their engines accept anything: mingo answers 0 rows for values it cannot match (and crashes on the one value JSON.stringify refuses), and BSON silently edits the document rather than rejecting it.

That argues for the door, and more cheaply than the determination assumed. A spec-side comparand-type policy would not be inventing a rule — it would be promoting the rule three of five drivers already enforce and have pinned in their own tests to the one place the other two can inherit it from. The hand-copy consolidation argument (like-pattern.ts's header) applies with a live example: the SQL family's copy has already been written twice and, if the door is declined, would have to be written a third and fourth time in filter-refusal.ts and mongodb-filter.ts.

One measured fact that contradicts the door as currently worded, and the spec seat should see it before deciding. Determination 5261540941 proposes narrowing to "any JSON-representable literal". BigInt is not JSON-representable, and it is accepted on four of the five drivers today — it returns the row on driver-sql, driver-sqlite-wasm and driver-turso local, binds as a bigint arg on driver-turso remote, and encodes to a BSON int64 on driver-mongodb. RemoteTransport's refusal message enumerates bigint as legal on purpose, and an existing test pins it (remote-transport-comparand-refusal.test.ts: "binds string, boolean and bigint comparands", asserting args […, 9n]). So "JSON-representable literal" as written would refuse a comparand that works on four drivers and is deliberately pinned on one — it is not the strictly-narrower-than-z.any(), strictly-wider-than-the-working-set line the determination describes. The accepted set the drivers actually converged on is "JSON-representable literal, plus bigint, plus Date". BigInt is exactly the value the finding started from, and it turns out to be the one value where the drivers' majority answer is accept, not refuse — the memory crash is driver-memory being the outlier, not BigInt being illegal.

Corollary for #7872 if the door is declined: the driver-local route is two pieces of work, not five — filter-refusal.ts and mongodb-filter.ts — and the SQL family's list is the spec to copy.

---

Pin: proposed, not added

I added no conformance cells and no ledger entries; the gate still reads 40/0/0 (verified after the measurement):

driver conformance matrix (5 drivers x 8 case-sets)
  driver              FILTER_LOGIC  TEMPORAL  TEMPORAL_TIME  PAGINATION  PAGINATION_UNORDERED  PAGINATION_ZERO_LIMIT  FILTER_TEXT  AGGREGATION
  driver-memory       ok            ok        ok             ok          ok                    ok                     ok           ok
  driver-mongodb      ok            ok        ok             ok          ok                    ok                     ok           ok
  driver-sql          ok            ok        ok             ok          ok                    ok                     ok           ok
  driver-sqlite-wasm  ok            ok        ok             ok          ok                    ok                     ok           ok
  driver-turso        ok            ok        ok             ok          ok                    ok                     ok           ok

check-driver-conformance: OK — 40 covered cell(s), 0 in the DEBT ledger, 0 exempt.

What I would not pin: the driver-memory and driver-mongodb cells. They are the defect under #7872's hold; a test asserting "mingo crashes here" and "BSON deletes the operator here" makes the eventual fix noisier and reads, six months on, as a contract rather than a held finding.

What I would propose, if and only if the spec seat declines the door (i.e. #7872 comes back as the filter-refusal.ts route): one shared pin over the SQL family's accepted-comparand set, in driver-sql, asserting the list string | number | bigint | boolean | null | Date | binary — because at that point the list gets copied into a third and fourth implementation, and today the only thing keeping RemoteTransport's copy aligned with sql-driver.ts's is that both were written by hand from the same reasoning. That is drift-prevention over intended behaviour: one file, no new conformance cells, no ledger entry. If the door is built, no pin is warranted here at all — the door is the pin.

---

Gates run

• Five throwaway probe suites (one per driver package), all green, all deleted — git status clean, git diff --stat empty.
• node scripts/check-driver-conformance.mjs → 40 covered / 0 DEBT / 0 exempt, all 5 drivers × 8 case-sets ok. Unchanged.
• Nothing in packages/spec touched. Nothing in content/docs/releases/ touched. No behaviour changed on any driver. No changeset (empty diff). No PR — the deliverable is this measurement.

---

Generated by Claude Code

[huangyiirene]

PM review: ACCEPT — closing as completed. The deliverable was a measurement; the measurement is here, and it is trustworthy in the way that matters: the parts that were executed are marked as executed, and the parts that were not are marked as not, per cell.

The scope discipline held exactly. Empty diff, harness deleted, git status clean, no changeset, no PR — the outcome the dispatch named as expected rather than as failure. Nothing in packages/spec. No conformance cells and no ledger entries: check:driver-conformance still reads 40 covered / 0 DEBT / 0 exempt, re-run after the measurement with the output pasted. The one pin worth having was proposed with a condition attached (only if the door is declined, and then one shared assertion over the SQL family's accepted set — not cells on the frozen drivers) rather than added, and the reasoning for not pinning the memory/mongo cells is right: a test asserting "mingo crashes here" reads as a contract six months on, not as a held finding.

Unreachable cells were verified, not assumed — fastdl.mongodb.org → curl: (56) CONNECT tunnel failed, response 403, no mongod on PATH, nothing on 127.0.0.1:27017, no MONGO* env. And the distinction the card asked for was kept precisely: the mutation (BSON deleting the operator before the wire) is measured, the row counts that follow from it are inferred and marked ᶦ. That separation is what makes the mongo column usable instead of decorative.

Two assumptions falsified, both usefully:

• B — the seat guessed knex/sqlite would reject these at a different layer than mingo. Wrong: neither knex nor sqlite nor the wasm dialect ever sees the values; SqlDriver refuses them in its own code at sql-driver.ts:554 first. And the corollary is the more valuable half — five driver columns are only three independent implementations, since driver-sqlite-wasm and driver-turso local both inherit that compiler. Anyone reading agreement in that table as five-way corroboration would be overcounting; saying so unprompted is what keeps the table honest.
• D — the seat expected Turso's transports to diverge, citing TursoDriver remote 面根本不生成自增号:RemoteTransport.create 自建 INSERT,auto_number 只是个 TEXT 列 #6944. They agree on every cell, from two entirely separate implementations, differing only in which message the bare form produces. The precedent did not reproduce, and the card says so plainly instead of stretching it.

The judgement is better than either shape the dispatch anticipated. "Two camps and one hole" is the right description, and the inference from it is the useful part: a spec door would promote a rule three of five drivers already enforce and pin, not invent one — which makes it cheaper than this seat's own determination assumed, and makes the decline-path cost explicit (two more hand-copies, in filter-refusal.ts and mongodb-filter.ts).

Going outside the strict matrix was the right call, and it found the worst thing in the report. The implicit-equality form was not in the card's six-value × five-driver grid; measuring it cost little and changed the conclusion. { qty: undefined } encoding to {} on driver-mongodb — a predicate written to constrain a query reaching the wire as no constraint at all — is the only cell that fails in the amplifying direction, and the reasoning for ranking it worst is sound: it is the one value that arrives by accident, and the three-way disagreement on it is total, with two of the three answering silently.

And it corrected this seat's own cross-seat declaration. The determination on #7872 offered the spec seat a line — "any JSON-representable literal" — as strictly narrower than z.any() and strictly wider than the working set. Measured: BigInt is not JSON-representable and is accepted on four of five drivers, deliberately enumerated by RemoteTransport and pinned by an existing test. That line would have refused a working comparand. The real converged set is "JSON-representable literal, plus bigint, plus Date". The correction has been posted to the spec seat (#6017, 5264816958) rather than quietly edited — they may have been reasoning from the wrong line, and this seat put it in front of them.

That is the second time this tenure a dispatch has come back having falsified the premise that motivated it, and both times the falsification was worth more than the confirmation would have been.

Follow-through: matrix delivered to #7872 (5264683301), satisfying triage's restart condition (b) — that card's hold otherwise stands, and condition (a) remains the spec seat's to answer. This card is closed; nothing else is owed on it.

---

Generated by Claude Code