@@ -213,7 +213,7 @@ import {
 // `resolveMetadataItemName` below for why this registrar lost its fourth copy.
 import { deriveViewContainerObject } from '@objectstack/metadata/view-container';
 import { bindHooksToEngine } from './hook-binder.js';
-import { validateRecord, normalizeMultiValueFields, coerceBooleanFields, ValidationError, buildFieldError, resolveFieldLabel, valueShapePostureSetByEnv, mediaPostureSetByEnv, isScannableValueShapeField, valueShapeStrictEffective, mediaStrictEffective } from './validation/record-validator.js';
+import { validateRecord, normalizeMultiValueFields, normalizeBlankTypedValues, coerceBooleanFields, ValidationError, buildFieldError, resolveFieldLabel, valueShapePostureSetByEnv, mediaPostureSetByEnv, isScannableValueShapeField, valueShapeStrictEffective, mediaStrictEffective } from './validation/record-validator.js';
 import type { AdmittedValueShapeViolation, AdmittedValueShapeViolationSink } from './validation/record-validator.js';
 import type { RelatedFieldBinding, RelatedRecordBinding } from './validation/rule-validator.js';
 import { collectPredicateRelationships, evaluateValidationRules, optionVisibilityReadsPermissions, readsPermissionPredicate, referentialClearBinding, needsPriorRecord, stripReadonlyWhenFields, stripReadonlyWhenFieldsMulti, hasReadonlyWhenInPayload, hasParentScopedReadonlyWhenInPayload, hasParentScopedRequiredWhen, stripReadonlyFields, stripRuntimeOwnedFields, staticReadonlyInsertSubject, preserveAuditIgnoredOnInsertWarning } from './validation/rule-validator.js';
@@ -11751,7 +11751,11 @@ export class ObjectQL implements IObjectQLEngine {
     // those arms, and the families it does not carry).
     // `update()` deliberately does not default (#2706: a PATCH's explicit
     // `null` means "clear it"), so neither does an `update`-mode preview.
-    const rawRows = Array.isArray(data) ? data : [data];
+    // [#20308] The write doors read a blank on a non-string-typed column as
+    // `null` before anything else; the preview does the same at the same point,
+    // or a blank on a required field with a `defaultValue` would preview
+    // `required` while the write takes the default.
+    const rawRows = normalizeBlankTypedValues(schemaForValidation, Array.isArray(data) ? data : [data]);
     const nowSnapshot = new Date();
     // [#20082] The preview's ONE permission resolution, shared by its CEL
     // defaults and its option gates below, exactly as the write shares one. A
@@ -11917,6 +11921,14 @@ export class ObjectQL implements IObjectQLEngine {
     // hook, default or validation runs, so a refusal costs nothing.
     this.enforceTransactionOrigin(object, driver, 'insert');
 
+    // [#20308] A blank on a non-string-typed column is `null` from here on —
+    // before the middleware, the caller snapshot, the defaults, the hooks and
+    // validation read the payload, so all of them see one image (a blank then
+    // takes a `defaultValue` exactly as `null` does). See
+    // `normalizeBlankTypedValues` for the scope; it never mutates the caller's
+    // rows.
+    data = normalizeBlankTypedValues(this._registry.getObject(object), data);
+
     const opCtx: OperationContext = {
       object,
       operation: 'insert',
@@ -12955,6 +12967,13 @@ export class ObjectQL implements IObjectQLEngine {
      // itself. Resolve first, then extract.
      options = this.withResolvedWhere(options);
 
+     // [#20308] The insert door's rule, same place: a blank on a
+     // non-string-typed column is `null` before the middleware, the
+     // caller-value snapshot (`suppliedValues`), the hooks, the read-only
+     // strips and validation read the payload — so a `readonlyWhen` lock judges
+     // the value it snapshotted. See `normalizeBlankTypedValues`.
+     data = normalizeBlankTypedValues(this._registry.getObject(object), data);
+
      // 1. Extract ID from data or where if it's a single update by ID.
      //    Only a SCALAR `where.id` means "update one row by primary key". An
      //    operator object ({ $in: [...] }, { $ne: ... }, …) is a multi-row
 
@@ -65,6 +65,8 @@ import {
   REFERENCE_VALUE_TYPES,
   FILE_REFERENCE_TYPES,
   STRUCTURED_JSON_TYPES,
+  NUMERIC_VALUE_TYPES,
+  NON_TEXT_STORED_VALUE_TYPES,
   percentScaleOf,
 } from '@objectstack/spec/data';
 import type { FieldErrorCode } from '@objectstack/spec/api';
@@ -515,6 +517,84 @@ export function normalizeMultiValueFields(
   }
 }
 
+/**
+ * [#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.
+ *
+ * "Blank" is exactly what {@link isMissing} calls missing: `''` or a string of
+ * whitespace. "Non-string-typed" is the spec's `NON_TEXT_STORED_VALUE_TYPES` —
+ * the numeric class (`progress` and `summary` included), the boolean class,
+ * `date`, `datetime` and `time`. Read as the constant, never re-listed.
+ *
+ * ## Why the door has to say it
+ *
+ * The validator has always READ a blank as missing: `validateOne` returns on
+ * `isMissing` before any type check. Nothing WROTE it that way, so the blank
+ * went on to the driver exactly as sent — memory and SQLite stored `''` in a
+ * number, boolean, date, datetime or time column, and PostgreSQL refused the
+ * statement (`22P02` / `22007`, a `500` at REST). One clear of one field, three
+ * outcomes; objectui's date and time boxes send `''` when cleared. This makes
+ * storage agree with the platform's own reading.
+ *
+ * ## What it does NOT touch
+ *
+ * ⛔ Every string-stored column — text, lookup ids, select values. There `''`
+ * is a value, and the spec's value round-trip fixture pins it (`str_empty`:
+ * an empty string must not become null). What "empty" means for those types is
+ * a separate question, not answered here. ⛔ A non-blank value, and every
+ * non-string value, of any type: `null`, `0`, `false`, `'abc'` pass through
+ * untouched, so every type check and refusal downstream sees what it saw.
+ *
+ * ## Where it runs, and why there
+ *
+ * `ObjectQL.insert()` / `update()` apply it to the CALLER'S payload before
+ * anything else reads it — before the middleware chain, the caller-value
+ * snapshots, `defaultValue`s, the hooks, the strips and validation. So every
+ * stage agrees on one image: a `readonlyWhen` lock judges the same value it
+ * snapshots, a blank takes a declared `defaultValue` on insert exactly as an
+ * explicit `null` does (`applyFieldDefaults`, #2706), and `required` refuses
+ * it exactly as it refuses `null`. `ObjectQL.validate()` (the dry run) applies
+ * it at the same point, so a preview agrees with the write. ⛔ No driver copy:
+ * every REST, batch and import door reaches the engine through those methods.
+ *
+ * A value a `before*` hook writes AFTER the door is the hook's own, and is not
+ * normalised: a server-side producer writing `''` into a typed column is fixed
+ * at that producer.
+ *
+ * Takes one record or an array of them (the insert door's batch form). Pure:
+ * the caller's objects are never mutated — the same reference comes back when
+ * nothing changed, else a shallow copy (per row, and a copied array).
+ */
+export function normalizeBlankTypedValues<T>(
+  objectSchema: { fields?: Record<string, FieldDef> } | undefined | null,
+  data: T,
+): T {
+  const fields = objectSchema?.fields;
+  if (!fields || !data || typeof data !== 'object') return data;
+  if (Array.isArray(data)) {
+    let rows: unknown[] | undefined;
+    for (let i = 0; i < data.length; i++) {
+      const row = normalizeBlankTypedRow(fields, data[i]);
+      if (row !== data[i]) (rows ??= data.slice())[i] = row;
+    }
+    return (rows ?? data) as T;
+  }
+  return normalizeBlankTypedRow(fields, data) as T;
+}
+
+function normalizeBlankTypedRow(fields: Record<string, FieldDef>, row: unknown): unknown {
+  if (!isPlainRecord(row)) return row;
+  let out: Record<string, unknown> | undefined;
+  for (const [name, value] of Object.entries(row)) {
+    if (typeof value !== 'string' || !isMissing(value)) continue;
+    // Own-property: a field name may be `constructor` / `valueOf`.
+    const def = Object.prototype.hasOwnProperty.call(fields, name) ? fields[name] : undefined;
+    if (!def || !NON_TEXT_STORED_VALUE_TYPES.has(def.type)) continue;
+    (out ??= { ...row })[name] = null;
+  }
+  return out ?? row;
+}
+
 /**
  * Coerce `boolean`-typed fields from their SQL storage form (integer `0`/`1`,
  * or the strings `'0'`/`'1'`/`'true'`/`'false'`) into real JS booleans, on a
@@ -758,12 +838,30 @@ function validateOne(
     return null;
   }
 
-  // ── number types ────────────────────────────────────────────────
-  if (t === 'number' || t === 'currency' || t === 'percent' || t === 'rating' || t === 'slider') {
+  // ── number types (NUMERIC_VALUE_TYPES) ──────────────────────────
+  // The door is the SPEC'S numeric class, read as a constant for the reason the
+  // string branch above reads `BOUNDED_STRING_FIELD_TYPES` (#11875): a type
+  // joining the class there joins the type check here, with no second list to
+  // forget. It was a hand-list of five until #20308 — `progress` and `summary`,
+  // both members of the class, had no type check at all, so `'abc'` was stored
+  // verbatim in a numeric column on memory and SQLite (and failed at the
+  // driver, as a 500, on PostgreSQL).
+  if (NUMERIC_VALUE_TYPES.has(t)) {
     const n = typeof value === 'number' ? value : Number(value);
     if (!Number.isFinite(n)) {
       return fail('invalid_number');
     }
+    // [#20308] `progress` and `summary` joined the TYPE check above, and only
+    // that. The bounds and `scale` below keep the five types they always read:
+    //  - `summary` is also PLATFORM-written — the roll-up recompute stores its
+    //    aggregate through `update()` — and a platform-computed value has
+    //    nobody to refuse (the `scale` note below says so for `formula`).
+    //  - `scale`'s own contract names the types it is enforced on (`number`,
+    //    `percent`, `rating`, `slider`), and `min` / `max` on these two were
+    //    never enforced; starting to enforce either would narrow what a caller
+    //    may write, which is a separate decision from "a numeric column holds a
+    //    number".
+    if (t === 'progress' || t === 'summary') return null;
     if (def.min !== undefined && n < def.min) {
       return fail('min_value', { min: def.min });
     }
@@ -781,9 +879,9 @@ function validateOne(
     // refuse — so its `scale` is applied by rounding at the producer, in
     // `applyFormulaPlan`. Rounding here instead would convert #7501's rejection
     // into the silent alteration the ruling forbids. Nothing was carved out of
-    // #7501 to make that work: the type door below already excludes formula /
-    // summary / autonumber outputs from this function's reach, so the formula
-    // rounding fills a hole #7501 never covered.
+    // #7501 to make that work: formula / autonumber outputs never reach this
+    // branch, and a `summary` returns above, after the type check alone
+    // (#20308), so the formula rounding fills a hole #7501 never covered.
     // Only a well-formed declaration (integer ≥ 0) is enforced: `scale: 2.5`
     // has no defined meaning, and inventing one here (floor? round?) would be
     // the consumer-side guessing PD #12 forbids — a malformed declaration
@@ -992,8 +1090,9 @@ function validateOne(
     return null;
   }
 
-  // Remaining types (formula/summary/autonumber outputs, json/code payloads)
-  // are explicitly open per the spec contract — see field-value.zod.ts.
+  // Remaining types (formula/autonumber outputs, json/code payloads) are
+  // explicitly open per the spec contract — see field-value.zod.ts. (`summary`
+  // is judged by the numeric branch above since #20308.)
   return null;
 }