fix(tables): stop a blank cell blocking an optional type conversion

Found by Cursor Bugbot. `''` is incompatible with every numeric type, and the
compatibility scan counted it as a hard blocker regardless of whether the
target was optional — so a text column with a single empty cell could not be
converted to a number at all, and the error said 'to a required ...' either way.

An unreadable-but-empty cell is not a conversion failure. The write path
already turns an unreadable value into null on an optional column, so the
conversion now does the same and records null for it. A required target still
reports it, which the existing guard above already does with the message that
actually fits.

Also pins the two intentional divergences from the pre-registry behavior. A
differential run of the registry against the pre-refactor implementations (55
values x 7 column shapes) found ZERO coercion differences and exactly two
compatibility differences, both deliberate: boolean now rejects the '1'/'0'
conversions the old gate accepted and then nulled, and date now accepts the
epoch numbers its write path always accepted. Tests pin both so neither can be
silently reverted or widened.

Author: waleedlatif1

apps/sim/lib/table/__tests__/column-conversion.test.ts

@@ -139,3 +139,25 @@ describe('isValueCompatibleWithType — currency', () => {
     expect(isValueCompatibleWithType(1234.56, 'number')).toBe(true)
   })
 })
+
+describe('blank cells during conversion', () => {
+  // A text column with a single empty cell could not be converted to a number
+  // at all: `''` is incompatible with every numeric type, and the scan counted
+  // it as a hard blocker even when the target was optional — reporting it with
+  // an error that said "to a required ..." regardless.
+  it('treats an empty cell as incompatible with the numeric types', () => {
+    for (const type of ['number', 'currency'] as const) {
+      expect(isValueCompatibleWithType('', type)).toBe(false)
+    }
+  })
+
+  it('still accepts an empty string for text, which can legitimately hold it', () => {
+    expect(isValueCompatibleWithType('', 'string')).toBe(true)
+    expect(isValueCompatibleWithType('', 'json')).toBe(true)
+  })
+
+  it('lets a cleared select cell through only when the target is optional', () => {
+    expect(isValueCompatibleWithType('', 'select', OPTIONS, false, false)).toBe(true)
+    expect(isValueCompatibleWithType('', 'select', OPTIONS, false, true)).toBe(false)
+  })
+})

apps/sim/lib/table/__tests__/column-type-registry.test.ts

@@ -17,6 +17,7 @@ import {
   COLUMN_TYPES,
   columnTypeById,
   isColumnType,
+  isValueCompatible,
 } from '@/lib/table/column-types'
 import type { ColumnDefinition } from '@/lib/table/types'
 import { validateColumnDefinition } from '@/lib/table/validation'
@@ -106,6 +107,38 @@ describe('conversion write-back', () => {
   })
 })
 
+describe('intentional divergences from the pre-registry behavior', () => {
+  // A differential run of the registry against the pre-refactor implementations
+  // (55 values x 7 column shapes) found ZERO coercion differences and exactly
+  // these compatibility differences. Both are deliberate fixes; pinning them
+  // here so neither can be silently reverted or quietly widened.
+
+  it('rejects boolean conversions the old gate accepted and then nulled', () => {
+    // The old gate accepted '1'/'0'/1/0 but the write path only ever accepted
+    // 'true'/'false' — so the conversion reported zero incompatible rows and
+    // then nulled every one of them. Rejecting is the honest answer.
+    const column: ColumnDefinition = { name: 'b', type: 'boolean' }
+    for (const value of ['0', '1', 0, 1]) {
+      expect(isValueCompatible(value, column)).toBe(false)
+      expect(COLUMN_TYPE_REGISTRY.boolean.coerce(value as never, column).ok).toBe(false)
+    }
+    for (const value of [true, false, 'true', 'false']) {
+      expect(isValueCompatible(value, column)).toBe(true)
+    }
+  })
+
+  it('accepts epoch numbers converting to date, which the old gate rejected', () => {
+    // The write path already accepted epoch numbers; only the gate disagreed.
+    // Now that they agree, the conversion is allowed — and safe, because the
+    // conversion writes the coerced ISO string back rather than leaving a bare
+    // number that `::timestamptz` cannot cast.
+    const column: ColumnDefinition = { name: 'd', type: 'date' }
+    expect(isValueCompatible(0, column)).toBe(true)
+    const coerced = COLUMN_TYPE_REGISTRY.date.coerce(0 as never, column)
+    expect(coerced.ok && typeof coerced.value).toBe('string')
+  })
+})
+
 describe('metadata ownership', () => {
   const column = (over: Partial<ColumnDefinition>): ColumnDefinition =>
     ({ name: 'c', type: 'string', ...over }) as ColumnDefinition

apps/sim/lib/table/columns/service.ts

@@ -646,8 +646,18 @@ export async function updateColumnType(
           targetRequired
         )
       ) {
-        if (effective === null || effective === '') blankCount++
-        else incompatibleCount++
+        // A cell the target cannot read but that is merely EMPTY is not a
+        // conversion failure — the write path already turns an unreadable value
+        // into null on an optional column, so the conversion does the same. Only
+        // a required target has a real problem with it, and the guard above has
+        // already reported those. Blocking here meant a text column with a
+        // single blank cell could not be converted to a number at all.
+        if (effective === null || effective === '') {
+          if (targetRequired) blankCount++
+          else coercedByRowId.set(row.id, null)
+        } else {
+          incompatibleCount++
+        }
         continue
       }