wip(group 4 round 1): services- and spec-lane matcher pointers

Claude-Session: https://claude.ai/code/session_017xfMoEjKUuSh2xYB8sCozp
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

packages/plugins/plugin-security/src/bootstrap-declared-capabilities.test.ts

@@ -36,8 +36,10 @@ function makeQl(declared: any[] = []) {
       if (object !== 'sys_capability') return [];
       const where = q?.where ?? {};
       // [#8470] A `null` comparand is IS NULL, not `=== null`: `driver-sql`
-      // compiles `{ field: null }` to `IS NULL`, `driver-memory`'s matcher uses
-      // `value == condition`, and MongoDB matches null-or-missing — none of them
+      // compiles `{ field: null }` to `IS NULL`, `driver-memory`'s query path
+      // matches null-or-missing through mingo (its reference matcher, retired by
+      // commit `8fec76a2b`, used `value == condition`), and MongoDB matches
+      // null-or-missing — none of them
       // is strict equality against an ABSENT key. `bootstrapSystemCapabilities`
       // (called by several cases below) scopes its curated lookup with
       // `organization_id: null`, which strict `===` would make unsatisfiable

packages/plugins/plugin-security/src/bootstrap-system-capabilities.test.ts

@@ -26,8 +26,10 @@ import { buildExistingByName } from './seed-name-lookup.js';
  *     unrelated to ownership. Insertion order is what the double used to model,
  *     and it models nothing.
  *  2. **A `null` comparand matches a null OR absent value.** `driver-sql`
- *     compiles `{ field: null }` to `IS NULL`; `driver-memory`'s matcher uses
- *     `value == condition`; MongoDB matches null-or-missing. Strict `===`, which
+ *     compiles `{ field: null }` to `IS NULL`; `driver-memory`'s query path
+ *     matches null-or-missing through mingo (its reference matcher, retired by
+ *     commit `8fec76a2b`, used `value == condition`); MongoDB matches
+ *     null-or-missing. Strict `===`, which
  *     this double used, matches NONE of them and would have made
  *     `organization_id: null` unsatisfiable here while working in production.
  *  4. **`$in` membership**, because the real engine has it (`security-plugin.ts`

packages/plugins/plugin-security/src/rls-check-stored-form.ts

@@ -37,7 +37,7 @@
  * - every comparand of the value comparisons on that column (`$eq`, `$ne`, the
  *   four orderings, `$in`, `$nin`, `$between`, and implicit equality), because
  *   the read compares the stored value against the comparand in that form
- *   (`driver-sql`'s `coerceFilterValue`, `driver-memory`'s matcher, objectql's
+ *   (`driver-sql`'s `coerceFilterValue`, `driver-memory`'s query path, objectql's
  *   `having` walker all pair the two). Putting only the image into the form
  *   would refuse a write the read shows whenever a policy spells its comparand
  *   another way: `record.start_time == '09:00'` against a stored `'09:00:00'`.

packages/services/service-analytics/src/strategies/filter-normalizer.ts

@@ -447,7 +447,9 @@
  * Row-result cover: `filter-operator-coverage.test.ts` for the operator
  * vocabulary, `native-sql-filter-logic-conformance.test.ts`, which runs the
  * SHARED combinator table (`FILTER_LOGIC_CASES`, #3774) that the SQL compiler,
- * the in-memory matcher, `formula` and `read-scope-sql` are already held to,
+ * `driver-memory`'s query path (its in-memory reference matcher, which ran the
+ * table too, was retired by commit `8fec76a2b`), `formula` and `read-scope-sql`
+ * are already held to,
  * `filter-normalizer-not-null-safe.test.ts` for the two squares that table
  * deliberately does not carry (NULL handling, boolean identities),
  * `filter-array-lowering.test.ts` for the array door (#5334),

packages/spec/src/data/filter-text-conformance.ts

@@ -339,8 +339,9 @@ export const FILTER_TEXT_CASES: readonly FilterTextCase[] = [
   // `$regex` and that driver answers them too. #6682\'s second half then took
   // the same flag off driver-memory\'s query path and off the rule its analytics
   // face borrows, which was the last folding face on the platform. (`formula`
-  // and driver-memory\'s reference matcher measured case-exact both then and
-  // now — they are what the other faces were moved onto.)
+  // measured case-exact both then and now, and driver-memory\'s reference
+  // matcher did until commit `8fec76a2b` retired it — they are what the other
+  // faces were moved onto.)
   {
     name: '$contains is case-SENSITIVE — a lower-case comparand misses the upper-case row',
     filter: { name: { $contains: 'acme' } },

packages/spec/src/data/filter.zod.ts

@@ -407,8 +407,10 @@ const ORDERING_COMPARAND_DESCRIPTION =
  * one form the platform's own date-macro path can never hand them. This is the
  * declaration aligning to a contract the rest of the stack already keeps, not
  * a new capability: every evaluation surface ALREADY compares strings
- * (`driver-sql` binds `>`/`>=`/`<`/`<=`, `formula`'s `matchesFilter` and
- * `driver-memory`'s matcher fall through to the JS operators).
+ * (`driver-sql` binds `>`/`>=`/`<`/`<=`, `formula`'s `matchesFilter` falls
+ * through to the JS operators, and `driver-memory`'s query path hands the
+ * comparison to mingo, which orders strings; its reference matcher, retired by
+ * commit `8fec76a2b`, fell through to the JS operators).
  *
  * ## Why a BARE string, and not an ISO-shaped refinement (#5685 rider ①)
  *
@@ -937,7 +939,7 @@ export const RangeOperatorSchema = lazySchema(() => z.object({
  * | `driver-sql` | ANSWERS both rows | its own `case '$icontains'`, folding through the same emitter that carries the escaping |
  * | `driver-sqlite-wasm` | ANSWERS both rows | INHERITED — `SqliteWasmDriver extends SqlDriver`; this package carries no text case arm of its own, on a different ENGINE |
  * | `driver-turso` | ANSWERS both rows, on BOTH transports | local inherits `SqlDriver`; the remote transport compiles independently and has its own arm |
- * | `driver-memory` — query path, reference matcher, analytics face | ANSWERS both rows | #6520; the pattern faces take {@link asciiCaseInsensitiveRegexSource}, the matcher {@link asciiCaseInsensitiveContains} |
+ * | `driver-memory` — query path, analytics face | ANSWERS both rows | #6520; both take {@link asciiCaseInsensitiveRegexSource} (its reference matcher took {@link asciiCaseInsensitiveContains} until commit `8fec76a2b` retired it) |
  * | `driver-mongodb` | ANSWERS both rows | #6520; an ASCII-only `$regex`, never `$options: 'i'` |
  * | objectql `having` | ANSWERS both rows | #6520; {@link asciiCaseInsensitiveContains} over the aggregated row |
  * | `formula` `matchesFilterCondition` | ANSWERS both rows | #6520; the same helper, on the RLS write-side `check` |
@@ -1194,16 +1196,17 @@ const ASCII_CASE_DELTA = 0x20; // 'a' - 'A'
  *
  * ## Why this is in the spec and not four times in four packages
  *
- * `$icontains` has six JS evaluation faces (`driver-memory`'s query path,
- * reference matcher and analytics face, `driver-mongodb`, objectql's `having`,
- * `@objectstack/formula`'s `matchesFilterCondition`) plus three SQL compilers in
+ * `$icontains` has five JS evaluation faces (`driver-memory`'s query path and
+ * analytics face, `driver-mongodb`, objectql's `having`,
+ * `@objectstack/formula`'s `matchesFilterCondition`; a sixth, `driver-memory`'s
+ * reference matcher, was retired by commit `8fec76a2b`) plus three SQL compilers in
  * `service-analytics`. Every one of them needs the same fold, and this repo has
  * already measured what happens when such a rule is written out per package:
  * *"a list written out here would agree with the spec on the day it was typed
  * and never again"* (`driver-memory/src/filter-refusal.ts`, on the operator
  * vocabulary) — the #3948 shape, reached through the fold instead of the word
  * list. One definition means a fold that is wrong is wrong everywhere at once,
- * which is the only way six faces can be held to one answer.
+ * which is the only way these faces can be held to one answer.
  *
  * ## Why not `toLowerCase()`
  *
@@ -1239,7 +1242,8 @@ export function foldAsciiCase(value: string): string {
  * [#6520] Does `haystack` contain `needle`, ignoring ASCII case only?
  *
  * The `$icontains` predicate for every face that can compare two JS strings
- * directly — the reference matcher, objectql's `having`, `formula`. The fold
+ * directly — objectql's `having` and `formula` (and `driver-memory`'s reference
+ * matcher until commit `8fec76a2b` retired it). The fold
  * runs on BOTH sides, which is the half that is easy to get wrong: folding only
  * the comparand compares a folded needle against a raw haystack and matches just
  * the rows that were already lower-case. `FILTER_TEXT_CASES`' first row (an
@@ -3108,7 +3112,7 @@ export const FilterArraySchema: z.ZodType<FilterArray, FilterArray> = z.lazy(()
  * |---|---|
  * | `driver-sql` (and `driver-sqlite-wasm`, which inherits its compiler) | ANSWERS — `LIKE` / `GLOB` per dialect, caller-bound wildcards |
  * | `driver-turso` — local (inherits `SqlDriver`) and remote (its own compiler) | ANSWERS on both transports |
- * | `driver-memory` — query path and reference matcher | ANSWERS — it widens its own `SUPPORTED_FIELD_OPERATORS` by hand, the way `driver-turso`'s remote transport has carried `$icontains` since #5702. It is the in-memory DOUBLE: an app whose tests run there and whose production runs SQL must not get a 400 for a filter that works |
+ * | `driver-memory` — query path (its reference matcher answered too until commit `8fec76a2b` retired it) | ANSWERS — it widens its own `SUPPORTED_FIELD_OPERATORS` by hand, the way `driver-turso`'s remote transport has carried `$icontains` since #5702. It is the in-memory DOUBLE: an app whose tests run there and whose production runs SQL must not get a 400 for a filter that works |
  * | `@objectstack/formula` `matchesFilterCondition` | ANSWERS — {@link matchesLikePattern}, so a write-side `check` agrees with the read-side SQL |
  * | `driver-mongodb`, `objectql` `having`, `service-analytics` | REFUSE, loudly, in the ADR-0112 `INVALID_FILTER` envelope — they derive acceptance from THIS array, which does not name the operator |
  *
@@ -3139,7 +3143,7 @@ export const FilterArraySchema: z.ZodType<FilterArray, FilterArray> = z.lazy(()
  * | `driver-turso` remote transport | the declared row, through the resolver `TursoDriver` wires |
  * | `driver-memory` query path, `driver-mongodb` | the declared row, from `syncSchema` |
  * | `service-analytics` — `where` and read-scope SQL | the declared row, from the host's `sourceFieldMeta` |
- * | `driver-memory` reference matcher, objectql `having`, `@objectstack/formula` `matchesFilterCondition` | by VALUE — null, `''` and `[]` are empty (they hold no declarations) |
+ * | objectql `having`, `@objectstack/formula` `matchesFilterCondition` (and `driver-memory`'s reference matcher until commit `8fec76a2b` retired it) | by VALUE — null, `''` and `[]` are empty (they hold no declarations) |
  * | `driver-memory` analytics (cube) face | REFUSES — `INVALID_FILTER` / 400, as it refuses `$null` |
  *
  * A declared-row face asked about a column it holds NO declaration for refuses

packages/spec/src/ui/view.zod.ts

@@ -602,9 +602,10 @@ const VIEW_FILTER_TEXT_COMPARAND_OPERATOR = 'icontains' satisfies ViewFilterOper
  *   `false` (an array is none of the six accepted comparand types —
  *   `isAcceptedFilterComparand`, `filter-comparand-type.ts`), and the comparand
  *   is refused with the withheld `INVALID_FILTER` / 400 envelope.
- * - **`driver-memory` REFUSES** the same shape in the same envelope — `match()`
- *   runs `assertFilterConditionShape`, whose implicit-equality arm throws on an
- *   array (`filter-refusal.ts`). That refusal first shipped in
+ * - **`driver-memory` REFUSES** the same shape in the same envelope — its query
+ *   path's `convertToMongoQuery` runs `assertFilterConditionShape`, whose
+ *   implicit-equality arm throws on an array (`filter-refusal.ts`); the reference
+ *   matcher's `match()` ran it too until commit `8fec76a2b` retired the matcher. That refusal first shipped in
  *   `@objectstack/driver-memory@17.4.0`; published 17.3.0 returned the row
  *   stored as `['a']` (run in this change's review; which other rows it
  *   selected is NOT MEASURED).