@@ -0,0 +1,28 @@
+---
+"@objectstack/spec": minor
+"@objectstack/formula": minor
+"@objectstack/driver-memory": minor
+---
+
+`$like` / `$ilike`: `_` matches exactly one Unicode code point on every face, so an emoji or any other character outside the Basic Multilingual Plane is one `_`, as SQL `LIKE` and SQLite `GLOB` count it (#20143).
+
+The SQLite faces (`driver-sql` on better-sqlite3, `driver-sqlite-wasm`, `driver-turso` local and remote) already answered by code points. The JavaScript faces did not: they compiled the spec's `likePatternToRegexSource` with no regular-expression flags, so `_` read one UTF-16 code unit, which is half of an emoji. The same REST filter returned a different row set depending on which driver backed the object. Measured at `e7f69dbb` over values holding `😀` (U+1F600) and `𝒜` (U+1D49C), 48 answer cells on the JS faces differed from the SQLite faces; after this change, none do.
+
+- **`@objectstack/spec`**: a new export, `likePatternToRegExp(pattern, foldAscii?)`, compiles the translation with the `u` flag, the one compilation in which `_` is one code point. `matchesLikePattern` evaluates it. `likePatternToRegexSource` is unchanged and still exported; its source means one code point per `_` only under `u`. The `$like` description now says that a character is one Unicode code point.
+- **`@objectstack/formula`**: `matchesFilterCondition` answers `$like` / `$ilike` by code points, through the spec's `matchesLikePattern`. Its own CEL `size()` already counted code points.
+- **`@objectstack/driver-memory`**: all three `$like` doors (the `$like` filter and the AST `like` / `ilike` node through mingo, and the reference matcher) answer by code points.
+
+The answer set moves in both directions on those three faces, only for values holding a character outside the BMP:
+
+| pattern | a stored `😀` | `a😀b` | `a😀😀b` |
+|---|---|---|---|
+| `_` | now matches | — | — |
+| `__` | no longer matches | — | — |
+| `a_b` | — | now matches | — |
+| `a__b` | — | no longer matches | now matches |
+
+`$ilike` moves the same way. No pattern is newly refused and no refusal is lifted. Values made only of characters inside the BMP answer exactly as before.
+
+Clause-②: yes (narrowing)
+
+<!-- adr-0087: not-required (no-migration-prescription) Nothing an author writes is removed or renamed: no spec key, no export and no config field moves, and no stored metadata representation changes, so `objectstack migrate meta` has nothing to rewrite. What moves is the row set a `$like` / `$ilike` query returns on the JavaScript faces, and only for stored values holding a character outside the BMP, where it now equals what every SQLite face already returned. -->
@@ -0,0 +1,84 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [#20143] driver-memory — `$like` / `$ilike` `_` is ONE Unicode code point on
+ * EVERY door, the answer every SQLite face gives.
+ *
+ * This driver answers `$like` on three doors: the `$`-spelling through mingo
+ * (`normalizeFilterCondition`), the AST comparison node `like` / `ilike`
+ * through mingo (`convertConditionToMongo`), and the reference matcher. The
+ * two mingo doors compiled the spec's `likePatternToRegexSource` with a local
+ * `new RegExp(...)` and no flags, and the matcher evaluated the spec's
+ * `matchesLikePattern`, which did the same — so all three read one UTF-16 code
+ * unit per `_`. Measured at base `e7f69dbb`: `$like: '_'` missed a stored
+ * `😀` that better-sqlite3, sql.js and `TursoDriver` (local, and remote on a
+ * real libSQL engine) all returned, on both mingo doors. The mingo doors now
+ * take the spec's `likePatternToRegExp` (the `u` flag), and the matcher
+ * inherits it through `matchesLikePattern`.
+ *
+ * Each door is asserted against the literal code-point rows, not merely
+ * against the others: parity alone is satisfied by breaking all three alike.
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { InMemoryDriver } from './memory-driver.js';
+import { match } from './memory-matcher.js';
+
+const GRIN = String.fromCodePoint(0x1f600);
+const SCRIPT_A = String.fromCodePoint(0x1d49c);
+const TABLE = 'like_code_point';
+
+const ROWS: Readonly<Record<string, string>> = {
+  x: 'x',
+  grin: GRIN,
+  grin_grin: GRIN + GRIN,
+  a_grin_b: 'a' + GRIN + 'b',
+  a_grin_grin_b: 'a' + GRIN + GRIN + 'b',
+  upper_script_b: 'A' + SCRIPT_A + 'B',
+  ab: 'ab',
+  axb: 'axb',
+  axyb: 'axyb',
+};
+
+/** [op, pattern, the code-point rows — the SQLite faces' answer]. */
+const FAMILY: ReadonlyArray<readonly ['$like' | '$ilike', string, readonly string[]]> = [
+  ['$like', '_', ['grin', 'x']],
+  ['$like', '__', ['ab', 'grin_grin']],
+  ['$like', 'a_b', ['a_grin_b', 'axb']],
+  ['$like', 'a__b', ['a_grin_grin_b', 'axyb']],
+  ['$like', '___', ['a_grin_b', 'axb', 'upper_script_b']],
+  ['$like', GRIN + '_', ['grin_grin']],
+  ['$like', '_' + GRIN, ['grin_grin']],
+  ['$ilike', '_', ['grin', 'x']],
+  ['$ilike', 'A_B', ['a_grin_b', 'axb', 'upper_script_b']],
+  ['$ilike', 'A__B', ['a_grin_grin_b', 'axyb']],
+];
+
+describe('[#20143] driver-memory — `_` is one code point on every door', () => {
+  let driver: InMemoryDriver;
+
+  beforeAll(async () => {
+    driver = new InMemoryDriver({ persistence: false, logger: { info() {}, warn() {}, error() {}, debug() {} } as never });
+    await driver.connect();
+    for (const [label, v] of Object.entries(ROWS)) await driver.create(TABLE, { label, v });
+  });
+
+  const labels = (rows: Array<Record<string, unknown>>): string[] => rows.map((r) => String(r.label)).sort();
+
+  it('stored every value whole (the premise)', async () => {
+    const rows = (await driver.find(TABLE, {})) as Array<{ label: string; v: string }>;
+    expect(Object.fromEntries(rows.map((r) => [r.label, r.v]))).toEqual(ROWS);
+  });
+
+  for (const [op, pattern, expected] of FAMILY) {
+    it(`${op} ${JSON.stringify(pattern)} answers the code-point rows on all three doors`, async () => {
+      const where = { v: { [op]: pattern } };
+      const ast = { type: 'comparison', field: 'v', operator: op === '$ilike' ? 'ilike' : 'like', value: pattern };
+      expect({
+        dollarQuery: labels(await driver.find(TABLE, { where: where as never })),
+        astQuery: labels(await driver.find(TABLE, { where: ast as never })),
+        matcher: Object.entries(ROWS).filter(([label, v]) => match({ label, v }, where)).map(([l]) => l).sort(),
+      }).toEqual({ dollarQuery: [...expected], astQuery: [...expected], matcher: [...expected] });
+    });
+  }
+});
@@ -9,7 +9,7 @@ import { canonicalAstOperator, asciiCaseInsensitiveRegexSource } from '@objectst
 // [#7536] `$like`/`$ilike`'s pattern language, from the spec's one definition —
 // the same translation `formula` evaluates and the same pattern `driver-sql`
 // hands to LIKE/GLOB, so this face cannot answer a pattern differently.
-import { hasDanglingLikeEscape, hasNulInLikePattern, likePatternToRegexSource } from '@objectstack/spec/data';
+import { hasDanglingLikeEscape, hasNulInLikePattern, likePatternToRegExp } from '@objectstack/spec/data';
 import type { DriverQuery, IDataDriver } from '@objectstack/spec/contracts';
 import { Logger, createLogger, nextUtcCalendarDay } from '@objectstack/core';
 import { Query, Aggregator } from 'mingo';
@@ -1393,8 +1393,10 @@ export class InMemoryDriver implements IDataDriver {
         if (hasDanglingLikeEscape(value)) throw danglingLikeEscapeError(field, canonical, value);
         // [#20041] The same U+0000 refusal as the `$`-spelling's shape gate.
         if (hasNulInLikePattern(value)) throw nulLikePatternError(field, canonical, value);
+        // [#20143] The spec's compiled RegExp, never a local `new RegExp`: it
+        // carries the `u` flag that makes `_` one code point, as on SQL.
         return {
-          [field]: { $regex: new RegExp(likePatternToRegexSource(value, canonical === 'ilike')) },
+          [field]: { $regex: likePatternToRegExp(value, canonical === 'ilike') },
         };
       }
       case 'notcontains': case 'not_contains':
@@ -1618,16 +1620,18 @@ export class InMemoryDriver implements IDataDriver {
           regexConditions.push({ $regex: new RegExp(asciiCaseInsensitiveRegexSource(val)) });
           break;
         // [#7536] `$like` / `$ilike` — the caller's OWN pattern, anchored to the
-        // whole value. `likePatternToRegexSource` is the spec's one translation
-        // of that language, the same one `formula` evaluates and the same
+        // whole value. `likePatternToRegExp` is the spec's one compilation of
+        // that language, the same one `formula` evaluates and the same
         // pattern `driver-sql` hands to `LIKE` / `GLOB`.
         //
         // Two things this arm must NOT copy from its neighbours above. It does
         // not `escapeRegex` the comparand — a `%` here is the caller's wildcard,
         // and escaping it back into a literal IS the wire defect #7536 closed,
-        // reproduced one layer down. And it does not pass the `i` flag: the
-        // `$ilike` fold is ASCII-only and lives in the pattern source, for the
-        // reason the `$icontains` arm above spells out at length.
+        // reproduced one layer down. And it does not build its own `RegExp`:
+        // the spec's carries the `u` flag that makes `_` one code point
+        // (#20143) and never the `i` flag — the `$ilike` fold is ASCII-only and
+        // lives in the pattern source, for the reason the `$icontains` arm
+        // above spells out at length.
         case '$like':
         case '$ilike':
           // The comparand's shape was settled by `assertFieldConstraintShape`
@@ -1640,7 +1644,7 @@ export class InMemoryDriver implements IDataDriver {
           if (hasDanglingLikeEscape(val)) throw danglingLikeEscapeError(field, op, val, path);
           if (hasNulInLikePattern(val)) throw nulLikePatternError(field, op, val, path);
           regexConditions.push({
-            $regex: new RegExp(likePatternToRegexSource(val, op === '$ilike')),
+            $regex: likePatternToRegExp(val, op === '$ilike'),
           });
           break;
         case '$between': {
 
@@ -0,0 +1,107 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [#20143] `SqlDriver` on better-sqlite3 — `$like` / `$ilike` `_` is ONE
+ * Unicode code point, and `@objectstack/formula` now gives the same rows.
+ *
+ * This face was already right: it compiles `$like` to GLOB over the spec's
+ * `likePatternToGlobPattern`, and GLOB's `?` counts code points. The JS faces
+ * compiled `likePatternToRegexSource` with no flags and counted UTF-16 code
+ * units, so measured at base `e7f69dbb` `$like: '_'` returned a stored `😀`
+ * here and not in `formula`. The spec's `likePatternToRegExp` now compiles with
+ * the `u` flag, and the last case holds this face and `formula` to one answer.
+ *
+ * Each case asserts the literal code-point rows, not only the parity: parity
+ * alone is satisfied by breaking both faces the same way. The same cells are
+ * pinned on `driver-sqlite-wasm`, both `driver-turso` transports,
+ * `driver-memory`, `formula` and the spec.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import type { DriverOptions, FilterCondition } from '@objectstack/spec/data';
+import { matchesFilterCondition } from '@objectstack/formula';
+import { SqlDriver } from './sql-driver.js';
+
+const GRIN = String.fromCodePoint(0x1f600);
+const SCRIPT_A = String.fromCodePoint(0x1d49c);
+const BYPASS: DriverOptions = { bypassTenantAudit: true };
+const TABLE = 'like_code_point';
+
+const ROWS: Readonly<Record<string, string>> = {
+  x: 'x',
+  grin: GRIN,
+  grin_grin: GRIN + GRIN,
+  a_grin_b: 'a' + GRIN + 'b',
+  a_grin_grin_b: 'a' + GRIN + GRIN + 'b',
+  upper_script_b: 'A' + SCRIPT_A + 'B',
+  ab: 'ab',
+  axb: 'axb',
+  axyb: 'axyb',
+};
+
+/** [op, pattern, the code-point rows]. */
+const FAMILY: ReadonlyArray<readonly ['$like' | '$ilike', string, readonly string[]]> = [
+  ['$like', '_', ['grin', 'x']],
+  ['$like', '__', ['ab', 'grin_grin']],
+  ['$like', 'a_b', ['a_grin_b', 'axb']],
+  ['$like', 'a__b', ['a_grin_grin_b', 'axyb']],
+  ['$like', '___', ['a_grin_b', 'axb', 'upper_script_b']],
+  ['$like', GRIN + '_', ['grin_grin']],
+  ['$like', '_' + GRIN, ['grin_grin']],
+  ['$ilike', '_', ['grin', 'x']],
+  ['$ilike', 'A_B', ['a_grin_b', 'axb', 'upper_script_b']],
+  ['$ilike', 'A__B', ['a_grin_grin_b', 'axyb']],
+];
+
+function formulaAnswer(where: FilterCondition): string[] {
+  return Object.entries(ROWS)
+    .filter(([, v]) => matchesFilterCondition({ v }, where))
+    .map(([label]) => label)
+    .sort();
+}
+
+describe('[#20143] SqlDriver on better-sqlite3 — `_` is one code point', () => {
+  let driver: SqlDriver;
+
+  const labelsWhere = async (where: FilterCondition): Promise<string[]> => {
+    const rows = (await driver.find(TABLE, { where }, BYPASS)) as Array<{ label: string }>;
+    return rows.map((r) => r.label).sort();
+  };
+
+  beforeAll(async () => {
+    driver = new SqlDriver({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+    await driver.initObjects([{ name: TABLE, fields: { label: { type: 'string' }, v: { type: 'text' } } }]);
+    for (const [label, v] of Object.entries(ROWS)) await driver.create(TABLE, { label, v }, BYPASS);
+  });
+
+  afterAll(async () => {
+    await driver.disconnect();
+  });
+
+  it('stored every value whole, as UTF-8 (the premise)', async () => {
+    const rows = (await driver.execute(`select label, hex(v) as h from ${TABLE}`)) as Array<{ label: string; h: string }>;
+    const stored = Object.fromEntries(rows.map((r) => [r.label, r.h]));
+    for (const [label, v] of Object.entries(ROWS)) {
+      expect(stored[label], label).toBe(Buffer.from(v, 'utf8').toString('hex').toUpperCase());
+    }
+  });
+
+  for (const [op, pattern, expected] of FAMILY) {
+    it(`${op} ${JSON.stringify(pattern)} answers the code-point rows`, async () => {
+      expect(await labelsWhere({ v: { [op]: pattern } } as FilterCondition)).toEqual([...expected]);
+    });
+  }
+
+  it('formula answers the same rows as this face on every family cell', async () => {
+    const differing: string[] = [];
+    for (const [op, pattern] of FAMILY) {
+      const where = { v: { [op]: pattern } } as FilterCondition;
+      const sql = await labelsWhere(where);
+      const js = formulaAnswer(where);
+      if (JSON.stringify(sql) !== JSON.stringify(js)) {
+        differing.push(`${op} ${JSON.stringify(pattern)}: sql ${JSON.stringify(sql)} != formula ${JSON.stringify(js)}`);
+      }
+    }
+    expect(differing).toEqual([]);
+  });
+});
@@ -0,0 +1,107 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [#20143] `driver-sqlite-wasm` (sql.js) — `$like` / `$ilike` `_` is ONE
+ * Unicode code point, and `@objectstack/formula` now gives the same rows.
+ *
+ * This face was already right: it compiles `$like` to GLOB over the spec's
+ * `likePatternToGlobPattern`, and GLOB's `?` counts code points. The JS faces
+ * compiled `likePatternToRegexSource` with no flags and counted UTF-16 code
+ * units, so measured at base `e7f69dbb` `$like: '_'` returned a stored `😀`
+ * here and not in `formula`. The spec's `likePatternToRegExp` now compiles with
+ * the `u` flag, and the last case holds this face and `formula` to one answer.
+ *
+ * Each case asserts the literal code-point rows, not only the parity: parity
+ * alone is satisfied by breaking both faces the same way. The same cells are
+ * pinned on `driver-sql` (better-sqlite3), both `driver-turso` transports,
+ * `driver-memory`, `formula` and the spec.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import type { DriverOptions, FilterCondition } from '@objectstack/spec/data';
+import { matchesFilterCondition } from '@objectstack/formula';
+import { SqliteWasmDriver } from './index.js';
+
+const GRIN = String.fromCodePoint(0x1f600);
+const SCRIPT_A = String.fromCodePoint(0x1d49c);
+const BYPASS: DriverOptions = { bypassTenantAudit: true };
+const TABLE = 'like_code_point';
+
+const ROWS: Readonly<Record<string, string>> = {
+  x: 'x',
+  grin: GRIN,
+  grin_grin: GRIN + GRIN,
+  a_grin_b: 'a' + GRIN + 'b',
+  a_grin_grin_b: 'a' + GRIN + GRIN + 'b',
+  upper_script_b: 'A' + SCRIPT_A + 'B',
+  ab: 'ab',
+  axb: 'axb',
+  axyb: 'axyb',
+};
+
+/** [op, pattern, the code-point rows]. */
+const FAMILY: ReadonlyArray<readonly ['$like' | '$ilike', string, readonly string[]]> = [
+  ['$like', '_', ['grin', 'x']],
+  ['$like', '__', ['ab', 'grin_grin']],
+  ['$like', 'a_b', ['a_grin_b', 'axb']],
+  ['$like', 'a__b', ['a_grin_grin_b', 'axyb']],
+  ['$like', '___', ['a_grin_b', 'axb', 'upper_script_b']],
+  ['$like', GRIN + '_', ['grin_grin']],
+  ['$like', '_' + GRIN, ['grin_grin']],
+  ['$ilike', '_', ['grin', 'x']],
+  ['$ilike', 'A_B', ['a_grin_b', 'axb', 'upper_script_b']],
+  ['$ilike', 'A__B', ['a_grin_grin_b', 'axyb']],
+];
+
+function formulaAnswer(where: FilterCondition): string[] {
+  return Object.entries(ROWS)
+    .filter(([, v]) => matchesFilterCondition({ v }, where))
+    .map(([label]) => label)
+    .sort();
+}
+
+describe('[#20143] driver-sqlite-wasm (sql.js) — `_` is one code point', () => {
+  let driver: SqliteWasmDriver;
+
+  const labelsWhere = async (where: FilterCondition): Promise<string[]> => {
+    const rows = (await driver.find(TABLE, { where }, BYPASS)) as Array<{ label: string }>;
+    return rows.map((r) => r.label).sort();
+  };
+
+  beforeAll(async () => {
+    driver = new SqliteWasmDriver({ filename: ':memory:' });
+    await driver.initObjects([{ name: TABLE, fields: { label: { type: 'string' }, v: { type: 'text' } } }]);
+    for (const [label, v] of Object.entries(ROWS)) await driver.create(TABLE, { label, v }, BYPASS);
+  }, 60_000);
+
+  afterAll(async () => {
+    await driver.disconnect();
+  });
+
+  it('stored every value whole, as UTF-8 (the premise)', async () => {
+    const rows = (await driver.execute(`select label, hex(v) as h from ${TABLE}`)) as Array<{ label: string; h: string }>;
+    const stored = Object.fromEntries(rows.map((r) => [r.label, r.h]));
+    for (const [label, v] of Object.entries(ROWS)) {
+      expect(stored[label], label).toBe(Buffer.from(v, 'utf8').toString('hex').toUpperCase());
+    }
+  });
+
+  for (const [op, pattern, expected] of FAMILY) {
+    it(`${op} ${JSON.stringify(pattern)} answers the code-point rows`, async () => {
+      expect(await labelsWhere({ v: { [op]: pattern } } as FilterCondition)).toEqual([...expected]);
+    });
+  }
+
+  it('formula answers the same rows as this face on every family cell', async () => {
+    const differing: string[] = [];
+    for (const [op, pattern] of FAMILY) {
+      const where = { v: { [op]: pattern } } as FilterCondition;
+      const sql = await labelsWhere(where);
+      const js = formulaAnswer(where);
+      if (JSON.stringify(sql) !== JSON.stringify(js)) {
+        differing.push(`${op} ${JSON.stringify(pattern)}: sql ${JSON.stringify(sql)} != formula ${JSON.stringify(js)}`);
+      }
+    }
+    expect(differing).toEqual([]);
+  });
+});