@@ -0,0 +1,29 @@
+---
+"@objectstack/driver-sql": patch
+"@objectstack/driver-sqlite-wasm": patch
+"@objectstack/driver-turso": patch
+---
+
+fix(driver-sql, driver-turso): on SQLite, `$contains` / `$notContains` / `$icontains` / `$endsWith` read the whole stored value, instead of stopping at its first U+0000 (#20024)
+
+Clause-②: no
+
+On the SQLite faces these four operators compiled to `GLOB` for a comparand without U+0000, and SQLite's `glob()` reads the stored value only up to its first U+0000. Nothing raised, and the filter answered a different question. Measured on `SqlDriver` over better-sqlite3 (SQLite 3.53.4), on `SqliteWasmDriver` over sql.js (3.49.1), on `TursoDriver`'s local mode, and on its remote transport over a local libSQL engine (3.45.1). All four answered alike:
+
+- `$contains: 'b'` did not return a value stored as `'a'` + U+0000 + `'b'`;
+- `$endsWith: 'a'` returned that value, and `$endsWith: 'b'` did not;
+- `$notContains: 'b'` returned it;
+- `$icontains: 'B'` did not return `'A'` + U+0000 + `'B'`.
+
+What changes: these four operators now compile to the length-aware comparisons a comparand holding U+0000 already used, for every comparand. `$contains`, `$notContains` and `$icontains` use `instr()`, and `$endsWith` compares the value's trailing bytes over BLOB. An empty `$endsWith` comparand uses `instr()` too, so it still matches every non-NULL value. Such a filter now returns the rows `driver-memory` and `@objectstack/formula` return for it, under `$not`, `$or` and `$and` as well. The comparand is bound as written, so `*`, `?` and `[` in it are literal, as they were before. `$icontains` still folds ASCII letters only, and `$notContains` still returns a row whose value is NULL.
+
+- `@objectstack/driver-sql`: the SQLite arm of `SqlDriver`'s text-operator compiler. `SqliteWasmDriver` and `TursoDriver`'s local mode inherit it.
+- `@objectstack/driver-sqlite-wasm`: none of its own code changes. It inherits the fix.
+- `@objectstack/driver-turso`: the remote transport's own emitter, changed the same way.
+
+What does not change:
+
+- `$startsWith` with a comparand without U+0000 compiles to the same `GLOB` with the same bound pattern as before. The stored value's cut cannot change its answer.
+- No index is lost. The SQL `SqlDriver` compiles, run under `EXPLAIN QUERY PLAN` over an indexed TEXT column on all three engines, scanned the table for these four operators under `GLOB` and still does; `$startsWith` keeps its index search.
+- The Postgres and MySQL arms are untouched.
+- `$like` and `$ilike` still compile to `GLOB` on SQLite, so they still read a stored value only up to its first U+0000, and a pattern holding U+0000 is still cut there.
@@ -246,14 +246,18 @@ describe('[#15683] the per-dialect construct, compiled', () => {
           // No pattern operator, and no temporal presentation wrapper either:
           // the gate runs BEFORE both emitters, so nothing is built over the
           // column at all.
-          expect(sql, `${op} over ${probe.field}`).not.toMatch(/LIKE|GLOB|lower\(|translate\(|CAST\(|strftime|datetime\(/);
+          // [#20024] `instr(` is the SQLite substring construct now (`contains`).
+          expect(sql, `${op} over ${probe.field}`).not.toMatch(
+            /LIKE|GLOB|instr\(|lower\(|translate\(|CAST\(|strftime|datetime\(/,
+          );
         }
         const not = d.compileWhere({ [probe.field]: { $notContains: probe.hit } } as FilterCondition);
         expect(not, `$notContains over ${probe.field}`).toMatch(/where 1 = 1/);
-        expect(not, `$notContains over ${probe.field}`).not.toMatch(/LIKE|GLOB|IS NULL/);
+        expect(not, `$notContains over ${probe.field}`).not.toMatch(/LIKE|GLOB|instr\(|IS NULL/);
       }
-      // …and the text column beside them still compiles a real pattern match.
-      expect(d.compileWhere({ label: { $contains: '2026' } })).toMatch(/LIKE|GLOB/);
+      // …and the text column beside them still compiles a real substring match
+      // (`LIKE` on Postgres / MySQL, `instr()` on SQLite since #20024).
+      expect(d.compileWhere({ label: { $contains: '2026' } })).toMatch(/LIKE|GLOB|instr\(/);
     });
   }
 
 
@@ -255,10 +255,12 @@ describe('[#17343] the per-dialect construct, compiled — the registerExternalO
    * emitter OR the membership construct that replaced it for `$contains`. This
    * file's question is whether the declared-type gate fired, so it must accept
    * either; asserting one SHAPE here would make it red on the card that changes
-   * the other, which is exactly what #17590 did to its predecessor.
+   * the other, which is exactly what #17590 did to its predecessor. [#20024]
+   * On SQLite the substring emitter spells `contains` as `instr(` and `ends` as
+   * `substr(CAST(`; only `starts` and the `$like` pair keep `GLOB`.
    */
   const REAL_PREDICATE: Record<string, RegExp> = {
-    sqlite: /LIKE|GLOB|json_each\(/,
+    sqlite: /LIKE|GLOB|instr\(|substr\(CAST\(|json_each\(/,
     postgres: /LIKE|GLOB|::jsonb @> /,
     mysql: /LIKE|GLOB|JSON_CONTAINS\(/,
   };
@@ -286,7 +288,7 @@ describe('[#17343] the per-dialect construct, compiled — the registerExternalO
         for (const op of POSITIVE_OPERATORS) {
           const sql = d.compileWhere({ [field]: { [op]: 'true' } } as FilterCondition);
           expect(sql, `${op} over ${field}`).toMatch(/where 1 = 0/);
-          expect(sql, `${op} over ${field}`).not.toMatch(/LIKE|GLOB|lower\(|CAST\(/);
+          expect(sql, `${op} over ${field}`).not.toMatch(/LIKE|GLOB|instr\(|lower\(|CAST\(/);
         }
         expect(d.compileWhere({ [field]: { $notContains: 'true' } } as FilterCondition), field)
           .toMatch(/where 1 = 1/);
@@ -299,9 +301,10 @@ describe('[#17343] the per-dialect construct, compiled — the registerExternalO
         expect(d.compileWhere({ [field]: { $contains: 'red' } } as FilterCondition), field)
           .toMatch(REAL_PREDICATE[label]!);
       }
-      // …and the SCALAR string column among them is the one still on the pattern
-      // emitter, which is what keeps the row above from passing vacuously.
-      expect(d.compileWhere({ label: { $contains: 'red' } } as FilterCondition)).toMatch(/LIKE|GLOB/);
+      // …and the SCALAR string column among them is the one still on the
+      // substring emitter (`instr(` on SQLite since #20024), which is what keeps
+      // the row above from passing vacuously.
+      expect(d.compileWhere({ label: { $contains: 'red' } } as FilterCondition)).toMatch(/LIKE|GLOB|instr\(/);
     });
   }
 
 
@@ -257,15 +257,19 @@ describe('[#17590] the per-dialect membership construct, compiled', () => {
       for (const field of ['tags_', 'picks', 'nums']) {
         const sql = d.compileWhere({ [field]: { $contains: 'red' } } as FilterCondition);
         expect(sql, `${field} on ${label}`).toMatch(CONSTRUCT[label]!);
-        expect(sql, `${field} on ${label} must not be a pattern match`).not.toMatch(/LIKE|GLOB/);
+        // [#20024] The SQLite substring emitter spells `contains` as `instr(`
+        // and `ends` as `substr(CAST(`; only `starts` and `$like` keep `GLOB`.
+        expect(sql, `${field} on ${label} must not be a pattern match`).not.toMatch(
+          /LIKE|GLOB|instr\(|substr\(CAST\(/,
+        );
         expect(sql, `${field} on ${label} must not be a declared constant`).not.toMatch(/1 = 0|1 = 1/);
       }
     });
 
     it(`${label}: the SCALAR string column still compiles the PATTERN match`, () => {
       const d = new CompilerProbeDriver(config).declare();
       const sql = d.compileWhere({ label: { $contains: 'red' } } as FilterCondition);
-      expect(sql, `label on ${label}`).toMatch(/LIKE|GLOB/);
+      expect(sql, `label on ${label}`).toMatch(/LIKE|GLOB|instr\(/);
       expect(sql, `label on ${label}`).not.toMatch(CONSTRUCT[label]!);
     });
 
@@ -279,14 +283,16 @@ describe('[#17590] the per-dialect membership construct, compiled', () => {
 
     /**
      * The other text operators are NOT membership spellings and this card does
-     * not rule on them — they keep the lowering they had. Pinned so a later
-     * widening is a deliberate edit here rather than a silent side effect.
+     * not rule on them — they keep the text emitter's lowering (on SQLite, since
+     * #20024, `instr(` for `$icontains` and `substr(CAST(` for `$endsWith`).
+     * Pinned so a later widening is a deliberate edit here rather than a silent
+     * side effect.
      */
     it(`${label}: the rest of the text family is UNMOVED on a JSON column`, () => {
       const d = new CompilerProbeDriver(config).declare();
       for (const op of ['$startsWith', '$endsWith', '$icontains', '$like', '$ilike']) {
         const sql = d.compileWhere({ tags_: { [op]: 'red' } } as FilterCondition);
-        expect(sql, `${op} on ${label}`).toMatch(/LIKE|GLOB/);
+        expect(sql, `${op} on ${label}`).toMatch(/LIKE|GLOB|instr\(|substr\(CAST\(/);
         expect(sql, `${op} on ${label}`).not.toMatch(CONSTRUCT[label]!);
       }
     });
@@ -340,7 +346,8 @@ describe('[#17590] the per-dialect membership construct, compiled', () => {
       expect(d.compileWhere({ [field]: { $contains: 'x' } } as FilterCondition), field)
         .toMatch(CONSTRUCT.sqlite!);
     }
-    // …while the scalar string column of the same sweep still gets the pattern.
-    expect(d.compileWhere({ one_str: { $contains: 'x' } })).toMatch(/GLOB/);
+    // …while the scalar string column of the same sweep still gets the
+    // substring emitter (`instr(` on SQLite since #20024).
+    expect(d.compileWhere({ one_str: { $contains: 'x' } })).toMatch(/instr\(/);
   });
 });
@@ -27,8 +27,10 @@
  * well as pinned literally, so the table cannot drift from what the other
  * faces answer. `driver-memory` answered the same 50-row probe identically.
  *
- * A comparand WITHOUT U+0000 keeps `GLOB` and binds exactly what it bound
- * before, so no existing plan moves; the second block pins that.
+ * [#20024] A `$startsWith` comparand WITHOUT U+0000 keeps `GLOB` and binds
+ * exactly what it bound before; every `contains` / `ends` comparand now reads
+ * the whole stored value too (`sql-driver-20024-glob-stored-nul.test.ts`). The
+ * second block pins that split.
  */
 
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
@@ -213,22 +215,21 @@ describe('[#19999] the SQLite construct, compiled', () => {
   });
 
   /**
-   * A comparand without U+0000 compiles exactly as it did before this change —
-   * `GLOB`, one bound escaped pattern — so no existing plan moves (a
-   * `$startsWith` GLOB over an indexed column can still use the index).
+   * [#20024] Of the comparands without U+0000, only `$startsWith`'s keeps
+   * `GLOB` and its bound escaped pattern — so a `$startsWith` GLOB over an
+   * indexed column can still use the index. Every `contains` / `ends` shape
+   * reads the whole stored value now (`sql-driver-20024-glob-stored-nul.test.ts`).
    */
-  it('a comparand without U+0000 keeps GLOB and its pattern', () => {
-    expect(probe.compile({ v: { $contains: 'a*b' } })).toEqual({
+  it('a comparand without U+0000 keeps GLOB and its pattern for $startsWith only', () => {
+    expect(probe.compile({ v: { $startsWith: 'ab' } })).toEqual({
       sql: 'select * from `nul_text_match` where `v` GLOB ?',
-      bindings: ['*a[*]b*'],
+      bindings: ['ab*'],
     });
-    expect(probe.compile({ v: { $startsWith: 'ab' } }).bindings).toEqual(['ab*']);
-    expect(probe.compile({ v: { $endsWith: 'ab' } }).bindings).toEqual(['*ab']);
-    expect(probe.compile({ v: { $icontains: 'Ab' } })).toEqual({
-      sql: 'select * from `nul_text_match` where lower(`v`) GLOB lower(?)',
-      bindings: ['*Ab*'],
-    });
-    expect(probe.compile({ v: { $notContains: 'ab' } }).sql).toMatch(/`v` NOT GLOB \?/);
+    for (const op of ['$contains', '$notContains', '$icontains', '$endsWith'] as const) {
+      const { sql, bindings } = probe.compile({ v: { [op]: 'a*b' } } as FilterCondition);
+      expect(sql, op).not.toMatch(/GLOB/);
+      for (const b of bindings) expect(b, op).toBe('a*b');
+    }
   });
 
   /**