chore(spec): regenerate api-surface, export-origins and reference docs (#7536)

The four new pattern-language exports and the two new declared operators.
Also corrects the $like describe() and the FILTER_OPERATORS staging table,
which both said the JS faces refuse — driver-memory and formula answer.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PhHptz16p1kRmbmuzEZkgd

Author: claude

.changeset/like-wire-lowering.md

@@ -96,7 +96,10 @@ every face, by one shared test.
    `like` is now an exact match.
 2. **`like`/`ilike` on `driver-mongodb`, objectql `having` and analytics now
    return `400 INVALID_FILTER`** where a (wrong) substring answer came back
-   before. Write `$contains`/`$icontains` on those backends.
+   before. Write `$contains`/`$icontains` on those backends. `driver-memory` is
+   deliberately NOT in that list — it implements the operators, because an
+   application whose tests run on the in-memory double and whose production runs
+   SQL must not meet a 400 in test for a filter that works in production.
 3. **`@objectstack/client`'s `.contains()`, `.startsWith()` and `.endsWith()`
    emit different operators.** They used to build a `like` tuple by gluing
    wildcards onto the caller's value (`[field, 'like', '%' + value + '%']`),

content/docs/references/data/filter.mdx

@@ -148,6 +148,8 @@ Type: `[FilterArray](#filterarray)[]`
 | **$startsWith** | `string` | optional |  |
 | **$endsWith** | `string` | optional |  |
 | **$icontains** | `string` | optional | Contains substring, ignoring case — but ONLY ASCII case (A-Z against a-z). Every other character compares literally, so "café" does NOT match "CAFÉ" and "москва" does not match "МОСКВА". The domain is ASCII because that is the one fold all five backends can deliver: SQLite (and therefore turso and sqlite-wasm) folds ASCII only, so a Unicode promise here would be a guarantee three of the five could not keep. The comparand is matched LITERALLY — "%", "_" and regex metacharacters are ordinary characters, not wildcards. Case-SENSITIVE containment is $contains. [#5701 declared it; #5702 lowered it on the SQL family (driver-sql, driver-sqlite-wasm, driver-turso on both transports); #6520 lowered it on every JS evaluation face, so it is portable across every backend the platform ships.] |
+| **$like** | `string` | optional | Whole-string pattern match with CALLER-bound wildcards: "%" matches any sequence (including empty), "_" matches exactly one character, and a backslash escapes the character after it ("\\%", "\\_", "\\\\") so it matches literally. The pattern must cover the WHOLE value — a pattern with no wildcards is an exact comparison, NOT a substring search; write $contains for containment. A pattern ending in a lone unpaired backslash is refused (INVALID_FILTER). Comparison is case-SENSITIVE, same contract as $contains (#4706 Q2 = A); $ilike is the case-insensitive twin. [#7536. Answered by the SQL family (driver-sql, driver-sqlite-wasm, driver-turso on both transports), by driver-memory and by @objectstack/formula. driver-mongodb, objectql `having` and service-analytics REFUSE it in the INVALID_FILTER envelope rather than approximating it — see FILTER_OPERATORS for why it is staged out of that allowlist.] |
+| **$ilike** | `string` | optional | Whole-string pattern match like $like — "%" / "_" wildcards bound by the caller, backslash escapes — but ignoring ASCII case (A-Z against a-z) and ONLY ASCII case: "café" does NOT match "CAFÉ", the same #4706 Q1 = A boundary $icontains declares, because SQLite's fold is ASCII-only and three of the five backends are SQLite underneath. [#7536; staged with $like — see FILTER_OPERATORS.] |
 
 
 ---

packages/spec/api-surface/data.json

@@ -629,6 +629,7 @@
     "getSqliteConfigJsonSchema (const)",
     "getSqliteWasmConfigJsonSchema (const)",
     "getTursoConfigJsonSchema (const)",
+    "hasDanglingLikeEscape (function)",
     "hasDynamicTokens (function)",
     "hookForm (const)",
     "isApiOperationAllowed (function)",
@@ -654,7 +655,10 @@
     "isTitleEligible (function)",
     "isUniqueDeclared (function)",
     "isVirtualSearchField (function)",
+    "likePatternToGlobPattern (function)",
+    "likePatternToRegexSource (function)",
     "lintAuthoredRecordKeys (function)",
+    "matchesLikePattern (function)",
     "missingFieldValues (function)",
     "nextUtcCalendarDay (function)",
     "objectForm (const)",

packages/spec/export-origins/data.json

@@ -629,6 +629,7 @@
     "getSqliteConfigJsonSchema": "src/data/driver/sqlite.zod.ts#getSqliteConfigJsonSchema (const)",
     "getSqliteWasmConfigJsonSchema": "src/data/driver/sqlite.zod.ts#getSqliteWasmConfigJsonSchema (const)",
     "getTursoConfigJsonSchema": "src/data/driver/turso.zod.ts#getTursoConfigJsonSchema (const)",
+    "hasDanglingLikeEscape": "src/data/filter.zod.ts#hasDanglingLikeEscape (function)",
     "hasDynamicTokens": "src/data/autonumber-format.ts#hasDynamicTokens (function)",
     "hookForm": "src/data/hook.form.ts#hookForm (const)",
     "isApiOperationAllowed": "src/data/api-derivation.ts#isApiOperationAllowed (function)",
@@ -654,7 +655,10 @@
     "isTitleEligible": "src/data/display-name.ts#isTitleEligible (function)",
     "isUniqueDeclared": "src/data/field.zod.ts#isUniqueDeclared (function)",
     "isVirtualSearchField": "src/data/search-fields.ts#isVirtualSearchField (function)",
+    "likePatternToGlobPattern": "src/data/filter.zod.ts#likePatternToGlobPattern (function)",
+    "likePatternToRegexSource": "src/data/filter.zod.ts#likePatternToRegexSource (function)",
     "lintAuthoredRecordKeys": "src/data/authoring-key-lint.ts#lintAuthoredRecordKeys (function)",
+    "matchesLikePattern": "src/data/filter.zod.ts#matchesLikePattern (function)",
     "missingFieldValues": "src/data/autonumber-format.ts#missingFieldValues (function)",
     "nextUtcCalendarDay": "src/data/calendar-day.ts#nextUtcCalendarDay (function)",
     "objectForm": "src/data/object.form.ts#objectForm (const)",

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

@@ -476,9 +476,12 @@ export const StringOperatorSchema = lazySchema(() => z.object({
     + '$contains for containment. A pattern ending in a lone unpaired backslash '
     + 'is refused (INVALID_FILTER). Comparison is case-SENSITIVE, same contract '
     + 'as $contains (#4706 Q2 = A); $ilike is the case-insensitive twin. '
-    + '[#7536 declared it and lowered it on the SQL family; the JS evaluation '
-    + 'faces refuse it loudly until their follow-up lands — see '
-    + 'FILTER_OPERATORS for the staging.]'
+    + '[#7536. Answered by the SQL family (driver-sql, driver-sqlite-wasm, '
+    + 'driver-turso on both transports), by driver-memory and by '
+    + '@objectstack/formula. driver-mongodb, objectql `having` and '
+    + 'service-analytics REFUSE it in the INVALID_FILTER envelope rather than '
+    + 'approximating it — see FILTER_OPERATORS for why it is staged out of that '
+    + 'allowlist.]'
   ),
 
   /**
@@ -1688,8 +1691,9 @@ 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 |
  * | `@objectstack/formula` `matchesFilterCondition` | ANSWERS — {@link matchesLikePattern}, so a write-side `check` agrees with the read-side SQL |
- * | `driver-memory`, `driver-mongodb`, `objectql` `having`, `service-analytics` | REFUSE, loudly, in the ADR-0112 `INVALID_FILTER` envelope — because THIS array does not name the operator |
+ * | `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 |
  *
  * That split is the point rather than a gap: #7536 exists because a `like`
  * predicate was being SILENTLY given `$contains`' meaning, and a face that