@@ -7,9 +7,9 @@ fix(objectql): a cleared optional single-value `select` or `lookup` stores `null
 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.
+A cleared `select`, `lookup` or single file field sent as `''` was stored as sent. `''` is neither an option code, a record id nor a file 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.
+- **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 the `$empty` table puts on its `null_only` row whose value is one string: the option types (`select`, `radio`), the reference types (`lookup`, `master_detail`, `user`, `tree`) and the file references (`image`, `file`, `avatar`, `video`, `audio`). Unique or not. Object- and array-valued types (`json`, `composite`, `location`, …) and the engine-owned `formula` / `autonumber` keep what they store.
 - **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`.
 
@@ -1,31 +1,43 @@
 // Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
 
 /**
- * #29277 — the write door's arm for a cleared single-value option or reference
- * column, at the validator module: `normalizeBlankTypedValues` stores exactly
- * `''` as `null` on every OPTIONAL column whose type is string-stored
- * single-value (`SINGLE_OPTION_TYPES`, `REFERENCE_VALUE_TYPES`) and sits on the
- * `$empty` table's `null_only` row (maintainer ruling B on #29346, record
+ * #29277 — the write door's arm for a cleared one-string column on the
+ * `$empty` table's `null_only` row, at the validator module:
+ * `normalizeBlankTypedValues` stores exactly `''` as `null` on every OPTIONAL
+ * column the table puts on `null_only` whose value is one string — an option
+ * code, a record id, a file id (maintainer ruling B on #29346, record
  * 6579813296).
  *
- * `''` is neither an option code nor a record id, so it is no value on those
- * columns; the `$empty` table already reads only `null` as empty there, and is
- * unchanged. The population is read from the spec's own sets and the table's
- * own expansion, so a type joining either class tomorrow is covered here
- * without an edit. The engine and physical-column halves, through REST on
- * SQLite, are `packages/rest/src/rest-data-single-value-blank.test.ts`.
+ * The population is DERIVED from the table: every `FieldType` whose
+ * expansion is `null_only` and which is not typed (`NON_TEXT_STORED_VALUE_TYPES`,
+ * the #20308 arm) must be classified — one string (joins), object/array
+ * (`STRUCTURED_JSON_TYPES`, out) or engine-owned (`COMPUTED_VALUE_TYPES`,
+ * out) — so a type joining the row unclassified turns the first case red. The
+ * engine and physical-column halves, through REST on SQLite, are
+ * `packages/rest/src/rest-data-single-value-blank.test.ts`.
  */
 
 import { describe, it, expect } from 'vitest';
 import {
+  FieldType,
   REFERENCE_VALUE_TYPES,
   SINGLE_OPTION_TYPES,
+  FILE_REFERENCE_TYPES,
+  STRUCTURED_JSON_TYPES,
+  COMPUTED_VALUE_TYPES,
+  NON_TEXT_STORED_VALUE_TYPES,
   MULTI_CAPABLE_TYPES,
   expandEmptyOperator,
 } from '@objectstack/spec/data';
 import { normalizeBlankTypedValues } from './record-validator.js';
 
-const singleValue = [...SINGLE_OPTION_TYPES, ...REFERENCE_VALUE_TYPES];
+/** Every declarable type the `$empty` table puts on `null_only` that the typed arm does not own. */
+const nullOnlyUntyped = FieldType.options.filter(
+  (t) => expandEmptyOperator({ type: t }).arm === 'null_only' && !NON_TEXT_STORED_VALUE_TYPES.has(t),
+);
+const oneString = new Set<string>([...SINGLE_OPTION_TYPES, ...REFERENCE_VALUE_TYPES, ...FILE_REFERENCE_TYPES]);
+const singleValue = nullOnlyUntyped.filter((t) => oneString.has(t));
+const leftOut = nullOnlyUntyped.filter((t) => !oneString.has(t));
 const multiCapable = singleValue.filter((t) => MULTI_CAPABLE_TYPES.has(t));
 
 type Def = Record<string, unknown>;
@@ -45,12 +57,25 @@ function schemaOf(types: readonly string[], extra: Def = {}) {
 const rowOf = (types: readonly string[], value: unknown) => Object.fromEntries(types.map((t) => [`f_${t}`, value]));
 
 describe('normalizeBlankTypedValues: optional single-value option / reference columns (#29277)', () => {
-  it('the population is the ruled set, every member on the $empty table null_only row', () => {
-    // A control on the set itself: if it ever emptied, every case below would
-    // pass over nothing.
-    expect([...singleValue].sort()).toEqual(['lookup', 'master_detail', 'radio', 'select', 'tree', 'user']);
-    for (const t of singleValue) expect(expandEmptyOperator({ type: t }).arm, t).toBe('null_only');
-    expect(multiCapable.sort()).toEqual(['lookup', 'radio', 'select', 'user']);
+  it('every untyped null_only type is classified: one string joins, object/array and engine-owned stay out', () => {
+    for (const t of nullOnlyUntyped) {
+      const classes = [oneString.has(t), STRUCTURED_JSON_TYPES.has(t), COMPUTED_VALUE_TYPES.has(t)].filter(Boolean);
+      expect(classes, `${t}: exactly one storage class`).toHaveLength(1);
+    }
+    // Controls on the sets themselves: if one ever emptied, every case below
+    // would pass over nothing.
+    expect([...singleValue].sort()).toEqual(
+      ['audio', 'avatar', 'file', 'image', 'lookup', 'master_detail', 'radio', 'select', 'tree', 'user', 'video'],
+    );
+    expect([...leftOut].sort()).toEqual(
+      ['address', 'autonumber', 'composite', 'formula', 'json', 'location', 'record', 'repeater', 'vector'],
+    );
+    expect(multiCapable.sort()).toEqual(['file', 'image', 'lookup', 'radio', 'select', 'user']);
+  });
+
+  it('the left-out types keep "": object/array-stored and engine-owned', () => {
+    const row = rowOf(leftOut, '');
+    expect(normalizeBlankTypedValues(schemaOf(leftOut), row)).toBe(row);
   });
 
   it('"" on every optional member becomes null, unique or not', () => {
 
@@ -720,7 +720,7 @@ function isInReadonlyScope(name: string, def: FieldDef, scope: ReadonlyValueScop
  * [#20308] A BLANK string on a non-string-typed column is that column's typed
  * blank, `null` — the write door's one reading of it. [#29176] So is `''` on
  * an optional text-like column a unique constraint covers, and [#29277] `''`
- * on an optional single-value option or reference column (each its own
+ * on an optional single-value option, reference or file column (each its own
  * section below).
  *
  * "Blank" is exactly what {@link isMissing} calls missing: `''` or a string of
@@ -759,15 +759,15 @@ function isInReadonlyScope(name: string, def: FieldDef, scope: ReadonlyValueScop
  *  - a blank here also takes a declared `defaultValue` on insert, as the typed
  *    arm's does — the door runs before the defaults, by design.
  *
- * ## [#29277] Single-value option and reference columns
+ * ## [#29277] One-string columns on the `$empty` table's `null_only` row
  *
- * Exactly `''` on a column that is ALL of: string-stored single-value on the
- * `$empty` table's `null_only` row ({@link isSingleValueCodeColumn}: a
- * `SINGLE_OPTION_TYPES` or `REFERENCE_VALUE_TYPES` member that
- * `expandEmptyOperator` puts on `null_only`, so `multiple: true` is out), and
- * not `required: true` — is `null` from the door on, unique or not
- * (maintainer ruling B on #29346, record 6579813296). `''` is neither an
- * option code nor a record id, so it holds no value there; the ruled table
+ * Exactly `''` on a column that is ALL of: on the `$empty` table's
+ * `null_only` row (`expandEmptyOperator`, the table's own answer — so a
+ * `multiple: true` column, the `multi_value` row, is out), storing ONE string
+ * ({@link ONE_STRING_STORED_TYPES}), and not `required: true` — is `null` from
+ * the door on, unique or not (maintainer ruling B on #29346, record
+ * 6579813296; {@link isOneStringNullOnlyColumn}). `''` is neither an option
+ * code, a record id nor a file id, so it holds no value there; the ruled table
  * reads only `null` as empty on that row, and is unchanged — a row that
  * already stores `''` keeps answering as a value until a data step cleans it.
  * On a unique column the second record cleared is no longer refused `409`.
@@ -777,8 +777,9 @@ function isInReadonlyScope(name: string, def: FieldDef, scope: ReadonlyValueScop
  * ## What it does NOT touch
  *
  * ⛔ Every other string-stored column — text no unique constraint covers, a
- * `multiple: true` option or reference column (the table's `multi_value`
- * row), a file reference, a computed column. There `''` is a value, and the
+ * `multiple: true` option, reference or file column (the table's
+ * `multi_value` row), and the `null_only` types that do not store one string
+ * (see {@link ONE_STRING_STORED_TYPES}). There `''` is a value, and the
  * spec's value round-trip fixture pins it on text (`str_empty`: an empty
  * string must not become null). ⛔ A non-blank value, and every non-string value, of any
  * type: `null`, `0`, `false`, `'abc'` pass through untouched, so every type
@@ -854,28 +855,49 @@ function normalizeBlankTypedRow(
  * blank here would turn that refusal into a silent clear.
  *
  * The single-value option and reference types are not text-like: their arm
- * is {@link isSingleValueCodeColumn} (#29277), which needs no unique
+ * is {@link isOneStringNullOnlyColumn} (#29277), which needs no unique
  * constraint.
  */
 const UNIQUE_BLANK_TEXT_TYPES: ReadonlySet<string> = new Set(
   [...STRING_VALUE_TYPES].filter((t) => t !== 'password' && t !== 'secret'),
 );
 
 /**
- * [#29277] The string-stored single-value classes: an option code
- * (`SINGLE_OPTION_TYPES`) or a record id (`REFERENCE_VALUE_TYPES`), read as
- * the spec's constants, never re-listed.
+ * [#29277] The storage-shape half of the arm: the spec's value classes whose
+ * single value IS one string — an option code (`SINGLE_OPTION_TYPES`), a
+ * record id (`REFERENCE_VALUE_TYPES`), an opaque `sys_file` id
+ * (`FILE_REFERENCE_TYPES`; SQL stores it JSON-encoded, still one string to
+ * every reader). Read as the spec's constants, never re-listed. The spec has
+ * no predicate for "stores one string", so this set is stated here, and
+ * `record-validator.single-value-blank.test.ts` ties it to the table: every
+ * type on the `null_only` row that is not typed (`NON_TEXT_STORED_VALUE_TYPES`)
+ * must be in this set or in one of the two classes left out below, so a type
+ * that joins the row unclassified turns that pin red.
+ *
+ * Left out, each measured on SQLite through the engine:
+ *
+ *  - `STRUCTURED_JSON_TYPES` (`json`, `composite`, `record`, `location`,
+ *    `address`, `repeater`, `vector`): the value is an object or an array, so
+ *    `''` is not a blank of its shape. What empty means for them is a
+ *    separate question.
+ *  - `COMPUTED_VALUE_TYPES` (`formula`, `autonumber`; `summary` is typed): the
+ *    engine owns the value — a formula is never stored, an autonumber is
+ *    issued on insert whatever the caller sent, `''` included.
  */
-const SINGLE_VALUE_CODE_TYPES: ReadonlySet<string> = new Set([...SINGLE_OPTION_TYPES, ...REFERENCE_VALUE_TYPES]);
+const ONE_STRING_STORED_TYPES: ReadonlySet<string> = new Set([
+  ...SINGLE_OPTION_TYPES,
+  ...REFERENCE_VALUE_TYPES,
+  ...FILE_REFERENCE_TYPES,
+]);
 
 /**
- * [#29277] Is `def` a string-stored single-value column on the `$empty`
- * table's `null_only` row? The row is the table's own answer
- * (`expandEmptyOperator`), so a `multiple: true` column — the `multi_value`
- * row — is never one, and a type the table moves is followed without an edit.
+ * [#29277] Is `def` on the `$empty` table's `null_only` row, storing one
+ * string? The row is the table's own answer (`expandEmptyOperator`), read
+ * first: a `multiple: true` column — the `multi_value` row — is never one,
+ * and a type the table moves off the row is followed without an edit.
  */
-function isSingleValueCodeColumn(def: FieldDef): boolean {
-  return SINGLE_VALUE_CODE_TYPES.has(def.type) && expandEmptyOperator(def).arm === 'null_only';
+function isOneStringNullOnlyColumn(def: FieldDef): boolean {
+  return expandEmptyOperator(def).arm === 'null_only' && ONE_STRING_STORED_TYPES.has(def.type);
 }
 
 /**
@@ -889,8 +911,8 @@ function isSingleValueCodeColumn(def: FieldDef): boolean {
  *    for one. Both surfaces are read through `isUniqueDeclared`, the drivers'
  *    own predicate, so a text column the store does not constrain is never
  *    rewritten;
- *  - [#29277] a single-value option or reference column
- *    ({@link isSingleValueCodeColumn}), unique or not.
+ *  - [#29277] a one-string column on the `$empty` table's `null_only` row
+ *    ({@link isOneStringNullOnlyColumn}), unique or not.
  */
 function blankAsNullColumns(fields: Record<string, FieldDef>, indexes: unknown): ReadonlySet<string> {
   const covered = new Set<string>();
@@ -906,7 +928,7 @@ function blankAsNullColumns(fields: Record<string, FieldDef>, indexes: unknown):
   const out = new Set<string>();
   for (const [name, def] of Object.entries(fields)) {
     if (!def || SKIP_FIELDS.has(name) || def.required === true) continue;
-    if (UNIQUE_BLANK_TEXT_TYPES.has(def.type) ? covered.has(name) : isSingleValueCodeColumn(def)) out.add(name);
+    if (UNIQUE_BLANK_TEXT_TYPES.has(def.type) ? covered.has(name) : isOneStringNullOnlyColumn(def)) out.add(name);
   }
   return out;
 }
 
@@ -12,9 +12,11 @@
  * `NULL` as distinct from every `NULL`), and on every column the clear was not
  * empty to `$empty`, whose ruled table reads only `null` as empty on these
  * types. Maintainer ruling B on #29346 (record 6579813296): the write door
- * stores `''` as `null` on every optional column whose type is string-stored
- * single-value on the table's `null_only` row — `select`, `radio`, `lookup`,
- * `master_detail`, `user`, `tree` today.
+ * stores `''` as `null` on every optional column the table puts on its
+ * `null_only` row whose value is one string — `select`, `radio`, `lookup`,
+ * `master_detail`, `user`, `tree`, and the file references `image`, `file`,
+ * `avatar`, `video`, `audio` today (an opaque file id; SQL stores it
+ * JSON-encoded, and a cleared one collided the same way).
  *
  * The PHYSICAL column is read with the driver's own query builder. Pinned
  * beside it: the `$empty` table is unchanged (a row that already holds `''`
@@ -48,14 +50,23 @@ const OBJ = {
     c_master: { name: 'c_master', type: 'master_detail' as const, reference: 'svb_target' },
     c_user: { name: 'c_user', type: 'user' as const },
     c_tree: { name: 'c_tree', type: 'tree' as const },
+    c_image: { name: 'c_image', type: 'image' as const },
+    c_file: { name: 'c_file', type: 'file' as const },
+    c_avatar: { name: 'c_avatar', type: 'avatar' as const },
+    c_video: { name: 'c_video', type: 'video' as const },
+    c_audio: { name: 'c_audio', type: 'audio' as const },
+    u_image: { name: 'u_image', type: 'image' as const, unique: true },
     u_select: { name: 'u_select', type: 'select' as const, options: OPTS, unique: true },
     u_lookup: { name: 'u_lookup', type: 'lookup' as const, reference: 'svb_target', unique: true },
     grp: { name: 'grp', type: 'text' as const },
     i_lookup: { name: 'i_lookup', type: 'lookup' as const, reference: 'svb_target' },
   },
   indexes: [{ name: 'idx_svb_obj_grp_lookup', fields: ['grp', 'i_lookup'], unique: 'global' as const }],
 };
-const PER_TYPE = ['c_select', 'c_radio', 'c_lookup', 'c_master', 'c_user', 'c_tree'] as const;
+const PER_TYPE = [
+  'c_select', 'c_radio', 'c_lookup', 'c_master', 'c_user', 'c_tree',
+  'c_image', 'c_file', 'c_avatar', 'c_video', 'c_audio',
+] as const;
 const REQ = {
   name: 'svb_req', label: 'Required', systemFields: false,
   fields: {
@@ -136,17 +147,20 @@ describe('REST write doors on SQLite: a cleared optional single-value option / r
   let ctx: Ctx;
   beforeEach(async () => { ctx = await boot(); });
 
-  it('POST create with "" on every ruled type: 201, every column stores NULL', async () => {
+  it('POST create with "" on every joined type: 201, every column stores NULL', async () => {
     const res = await create(ctx, { id: 'p1', name: 'r1', ...allBlank });
     expect(res.status).toBe(201);
     const row = await ctx.stored('svb_obj', 'p1');
     for (const f of PER_TYPE) expect(row?.[f], f).toBeNull();
   });
 
-  it('PATCH clearing every ruled type: 200, every column stores NULL', async () => {
+  it('PATCH clearing every joined type: 200, every column stores NULL', async () => {
     // `c_user` is left unset: no `sys_user` is registered here to resolve an id.
     expect((await create(ctx, { id: 'e0', name: 'parent' })).status).toBe(201);
-    const set = { c_select: 'gold', c_radio: 'gold', c_lookup: 't1', c_master: 't1', c_tree: 'e0' };
+    const set = {
+      c_select: 'gold', c_radio: 'gold', c_lookup: 't1', c_master: 't1', c_tree: 'e0',
+      c_image: 'img_1', c_file: 'fil_1', c_avatar: 'ava_1', c_video: 'vid_1', c_audio: 'aud_1',
+    };
     expect((await create(ctx, { id: 'e1', name: 'r1', ...set })).status).toBe(201);
     const res = await patch(ctx, 'e1', allBlank);
     expect(res.status).toBe(200);
@@ -174,6 +188,13 @@ describe('REST write doors on SQLite: a cleared optional single-value option / r
     for (const id of ['w1', 'w2']) expect((await ctx.stored('svb_obj', id))?.u_lookup, id).toBeNull();
   });
 
+  it('unique image: two records created with "" both land (no 409)', async () => {
+    const a = await create(ctx, { id: 'g1', name: 'r1', u_image: '' });
+    const b = await create(ctx, { id: 'g2', name: 'r2', u_image: '' });
+    expect([a.status, b.status]).toEqual([201, 201]);
+    for (const id of ['g1', 'g2']) expect((await ctx.stored('svb_obj', id))?.u_image, id).toBeNull();
+  });
+
   it('a member of a declared unique index: same group, cleared lookup, both land', async () => {
     const a = await create(ctx, { id: 'i1', name: 'r1', grp: 'g', i_lookup: '' });
     const b = await create(ctx, { id: 'i2', name: 'r2', grp: 'g', i_lookup: '' });