@@ -10,6 +10,6 @@ Metadata-protocol: none
 A cleared text input is sent as `''`, and the write path stored it as sent. Every unique constraint the drivers build is NULL-distinct, so `null` never collides, but `''` is a value: the first record whose SKU (tax id, employee number, …) was cleared saved, and the second was refused "A record with this value already exists" although neither held a value. Measured on SQLite and the memory driver: two `''` rows collide, two `null` rows do not.
 
 - **Now.** The engine's write door, which `insert`, `insertMany`, `update` (by id and by predicate) and the dry run (`validate`) apply before anything else reads the payload, stores exactly `''` as `null` on a column that is text-like (`text`, `textarea`, `email`, `url`, `phone`, `markdown`, `html`, `richtext`, `code`, `color`, `signature`, `qrcode`), not `required`, and covered by a unique constraint: the field's own `unique`, or membership in a declared `indexes[]` entry carrying `unique`. Every REST, batch, upsert and import door reaches the engine through those methods.
-- **Unchanged.** A `required` field given `''` is refused `required` exactly as before, also when it declares a `defaultValue`. A real duplicate is still `409 UNIQUE_VIOLATION`. Whitespace is a value and is stored as sent. `password` and `secret` keep their `''` refusal. A column no unique constraint covers, and `select` / `lookup` columns, keep storing `''`.
+- **Unchanged.** A `required` field given `''` is refused `required` exactly as before, also when it declares a `defaultValue`. A real duplicate is still `409 UNIQUE_VIOLATION`. Whitespace is a value and is stored as sent. `password` and `secret` keep their `''` refusal. A text column no unique constraint covers keeps storing `''`. (Optional single-value `select` / `lookup` columns store a cleared `''` as `null` too, unique or not: a separate change in this release.)
 - **Defaults.** An optional unique field that declares a `defaultValue` now takes it on insert when sent `''`, exactly as when sent `null`.
 - **Rows already stored.** Existing `''` values are not migrated. They keep matching a `field = ''` filter; a newly cleared row matches `$null: true` instead. The `is_empty` filter (`$empty`) matches both, as before. A newly cleared row no longer collides with a stored `''`.
@@ -0,0 +1,16 @@
+---
+'@objectstack/objectql': patch
+---
+
+fix(objectql): a cleared optional single-value `select` or `lookup` stores `null`, so a second record cleared on a unique one is no longer refused `409 UNIQUE_VIOLATION`
+
+Clause-②: no
+Metadata-protocol: none
+
+A cleared `select` or `lookup` sent as `''` was stored as sent. `''` is neither an option code nor a record id, so it held no value, yet it was one to the store and to the `is_empty` filter: on a unique column the second record cleared was refused "A record with this value already exists", and on every column the cleared record did not match `is_empty` (`$empty`), whose ruled table reads only `null` as empty on these types.
+
+- **Now.** The engine's write door (`insert`, `insertMany`, `update` by id and by predicate, and the `validate` dry run; every REST, batch, upsert and import door reaches it) stores exactly `''` as `null` on every optional column whose type is a single-value option or reference type on the `$empty` table's `null_only` row: `select`, `radio`, `lookup`, `master_detail`, `user`, `tree`. Unique or not.
+- **Read shape.** Such a field cleared from now on reads back `null`, not `''`. It matches `is_empty` / `$empty: true`, `$null: true` and `field = null`, and no longer matches `field = ''`.
+- **Unchanged.** The `$empty` table itself. A `required` field given `''` is refused `required` as before, also when it declares a `defaultValue`. Whitespace is a value. A `multiple: true` option or reference column keeps what it stores. A real duplicate is still `409 UNIQUE_VIOLATION`.
+- **Defaults.** An optional field that declares a `defaultValue` now takes it on insert when sent `''`, exactly as when sent `null`.
+- **Rows already stored.** Existing `''` values are not migrated by this change; they keep answering as a value (`$empty: false`, `field = ''`) until a data step cleans them.
@@ -29,8 +29,9 @@
  *    runs BEFORE the caller-value snapshot the lock judges against;
  *  - the dry run (`validate()`) agrees with the write.
  *
- * The string-stored controls (`text`, `lookup`, `select`) keep their `''` —
- * the spec's `str_empty` side of the line.
+ * The text control keeps its `''` — the spec's `str_empty` side of the line;
+ * an optional `lookup` / `select` `''` is `null` since #29277
+ * (`validation/record-validator.single-value-blank.test.ts`).
  */
 
 import { describe, it, expect, beforeEach } from 'vitest';
@@ -155,7 +156,7 @@ describe('engine write doors: a blank on a non-string-typed column reaches the d
     await engine.insert('blank_door', payload);
     const sent = last('create');
     expectTypedNull(sent);
-    expect([sent.c_text, sent.c_lookup, sent.c_select]).toEqual(['', '', '']);
+    expect([sent.c_text, sent.c_lookup, sent.c_select]).toEqual(['', null, null]);
     // The caller's own object is never rewritten.
     expect(payload.f_number).toBe(blank);
   });
@@ -181,7 +182,7 @@ describe('engine write doors: a blank on a non-string-typed column reaches the d
     await engine.update('blank_door', { id: 'u1', ...blankTyped(''), ...STR_BLANK });
     const byId = last('update');
     expectTypedNull(byId);
-    expect([byId.c_text, byId.c_lookup, byId.c_select]).toEqual(['', '', '']);
+    expect([byId.c_text, byId.c_lookup, byId.c_select]).toEqual(['', null, null]);
 
     await engine.update('blank_door', blankTyped(''), { where: { id: { $in: ['u1'] } }, multi: true } as any);
     expectTypedNull(last('updateMany'));
 
@@ -22,8 +22,9 @@
  *    of a declared `indexes[]` entry carrying `unique`;
  *  - its edges, each a control: a column no unique constraint covers keeps
  *    `''` (the spec's `str_empty` side of the line); whitespace is a value, as
- *    the `$empty` operator's ruled table reads it; `select` / `lookup` keep
- *    `''` (not text-like); a non-blank value is untouched;
+ *    the `$empty` operator's ruled table reads it; a non-blank value is
+ *    untouched. (A unique `select` / `lookup` `''` is `null` too since #29277,
+ *    on every optional column, unique or not: `pick` / `ref` below.)
  *  - `required` is unchanged: a required unique field's `''` is refused
  *    `required` exactly as before — including when the field declares a
  *    `defaultValue`, which a blank rewritten to `null` would have taken;
@@ -135,10 +136,10 @@ const CRED = {
   },
 };
 
-/** The covered columns of {@link OBJ}: both unique surfaces, three scopes. */
-const COVERED_NAMES = ['sku', 'tax_id', 'email', 'code'];
-/** The columns that keep their `''`: no unique constraint, or not text-like. */
-const KEPT_NAMES = ['note', 'plain_idx', 'off', 'pick', 'ref'];
+/** The covered columns of {@link OBJ}: both unique surfaces, three scopes; and [#29277] the single-value select / lookup. */
+const COVERED_NAMES = ['sku', 'tax_id', 'email', 'code', 'pick', 'ref'];
+/** The text columns that keep their `''`: no unique constraint. */
+const KEPT_NAMES = ['note', 'plain_idx', 'off'];
 const blanksOf = (names: readonly string[]) => Object.fromEntries(names.map((n) => [n, '']));
 const COVERED = blanksOf(COVERED_NAMES);
 const KEPT = blanksOf(KEPT_NAMES);
 
@@ -26,9 +26,12 @@ import {
 import { normalizeBlankTypedValues, validateRecord, ValidationError } from './record-validator.js';
 
 const typed = [...NON_TEXT_STORED_VALUE_TYPES];
-// The string-stored controls: the whole string class, plus the other types
-// whose stored value is a string (`str_empty`'s side of the line).
-const stringStored = [...STRING_VALUE_TYPES, 'select', 'radio', 'lookup', 'master_detail', 'user', 'autonumber'];
+// The string-stored controls: the whole string class, plus a computed string
+// type (`str_empty`'s side of the line). The single-value option and reference
+// types store `''` as `null` since #29277, by their own arm
+// (`record-validator.single-value-blank.test.ts`); they are still not typed.
+const stringStored = [...STRING_VALUE_TYPES, 'autonumber'];
+const singleValueCode = ['select', 'radio', 'lookup', 'master_detail', 'user', 'tree'];
 
 function schemaOf(types: readonly string[]) {
   const fields: Record<string, { name: string; type: string; reference?: string; options?: unknown[] }> = {};
@@ -54,7 +57,7 @@ describe('normalizeBlankTypedValues (#20308)', () => {
     expect(typed.sort()).toEqual(
       ['boolean', 'currency', 'date', 'datetime', 'number', 'percent', 'progress', 'rating', 'slider', 'summary', 'time', 'toggle'],
     );
-    for (const t of stringStored) expect(NON_TEXT_STORED_VALUE_TYPES.has(t)).toBe(false);
+    for (const t of [...stringStored, ...singleValueCode]) expect(NON_TEXT_STORED_VALUE_TYPES.has(t), t).toBe(false);
   });
 
   it.each([[''], ['   '], ['\t\n']])('a blank %j on every non-string-typed column becomes null', (blank) => {
 
@@ -20,8 +20,10 @@ import { normalizeBlankTypedValues } from './record-validator.js';
 
 const CREDENTIAL = ['password', 'secret'];
 const textLike = [...STRING_VALUE_TYPES].filter((t) => !CREDENTIAL.includes(t));
-// Single-value string-stored types the `$empty` table reads `''` as a value on.
-const otherStringStored = ['select', 'radio', 'lookup', 'master_detail', 'user', 'autonumber'];
+// A string-stored type outside both string arms: `unique` alone never pulls it
+// in. (The single-value option and reference types have their own arm since
+// #29277, unique or not: `record-validator.single-value-blank.test.ts`.)
+const otherStringStored = ['autonumber'];
 
 type Def = Record<string, unknown>;
 function schemaOf(types: readonly string[], extra: Def = {}, indexes?: unknown[]) {
 
@@ -13,8 +13,9 @@
  * same bodies (`500 DATABASE_ERROR`; `failed` rows with `INTERNAL_ERROR` on the
  * batch doors). The door now stores the typed blank, `null`, on every door.
  *
- * Controls: a text / lookup / select `''` is stored as `''` (the spec's
- * `str_empty` — an empty string must not become null); a valid value on every
+ * Controls: a text `''` is stored as `''` (the spec's `str_empty` — an empty
+ * string must not become null), while an optional lookup / select `''` is
+ * `null` since #29277 (`rest-data-single-value-blank.test.ts`); a valid value on every
  * typed column is stored unchanged; a required field's blank is refused as
  * `400 VALIDATION_FAILED` / `required`; and a non-numeric string on `progress`
  * is refused as `invalid_number`.
@@ -152,12 +153,12 @@ describe('REST write doors on SQLite: a cleared typed column stores null (#20308
 
   const seed = (id: string) => ctx.engine.insert('blank_rest', { id, ...VALID });
 
-  it('POST create: the typed blanks store null; the string-stored blanks store ""', async () => {
+  it('POST create: the typed blanks store null; a text blank stores "", a lookup / select blank null (#29277)', async () => {
     const res = await ctx.call('POST', '/api/v1/data/:object', { object: 'blank_rest' }, { id: 'c1', ...blankTyped(), ...STR_BLANK });
     expect(res.status).toBe(201);
     const raw = await ctx.stored('blank_rest', 'c1');
     expectTypedNull(raw, 'stored');
-    expect([raw!.c_text, raw!.c_lookup, raw!.c_select]).toEqual(['', '', '']);
+    expect([raw!.c_text, raw!.c_lookup, raw!.c_select]).toEqual(['', null, null]);
     const read = await ctx.engine.findOne('blank_rest', { where: { id: 'c1' } });
     expectTypedNull(read as any, 'read');
     // The before-state's worst cell: a stored '' on a boolean read back as `false`.