fix(tables): keep TTL import coercion lightweight

Author: j15z

apps/sim/lib/table/column-types/ttl.ts

@@ -83,10 +83,6 @@ export const ttlColumnType: ColumnTypeDefinition = {
     return seconds === null ? { ok: false } : { ok: true, value: seconds }
   },
 
-  coerceForImport(value, context) {
-    return parseTtlEpochSeconds(value, context) ?? String(value)
-  },
-
   valueForConversion(value, target: ColumnDefinition) {
     if (target.type !== 'date') return value
     return epochSecondsToIso(value) ?? value

apps/sim/lib/table/column-types/types.ts

@@ -167,9 +167,6 @@ export interface ColumnTypeDefinition {
     context?: NormalizeDateCellOptions
   ): CoerceResult
 
-  /** Import-only normalization when invalid raw text must survive for row-level validation. */
-  coerceForImport?(value: unknown, context?: NormalizeDateCellOptions): Exclude<JsonValue, Date>
-
   /** Source-owned normalization applied before checking or rewriting a type conversion. */
   valueForConversion?(value: JsonValue, target: ColumnDefinition): JsonValue
 

apps/sim/lib/table/import.ts

@@ -14,7 +14,8 @@
 import type { Options as CsvParseOptions } from 'csv-parse'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { getColumnId } from '@/lib/table/column-keys'
-import { type ColumnType, columnTypeById } from '@/lib/table/column-types'
+import type { ColumnType } from '@/lib/table/column-types'
+import { parseTtlEpochSeconds } from '@/lib/table/column-types/ttl'
 import { parseCurrencyInput } from '@/lib/table/currency'
 import { type NormalizeDateCellOptions, normalizeDateCellValue } from '@/lib/table/dates'
 import type { ColumnDefinition, RowData, TableSchema } from '@/lib/table/types'
@@ -468,11 +469,10 @@ export function inferSchemaFromCsv(
  * back to the original string when unparseable so that schema validation can
  * reject it with context rather than silently inserting `null`.
  *
- * Deliberately not routed through the registry's ordinary `coerce`: that
- * contract is "coerced or rejected", while an import needs invalid raw text to
- * survive so row-level validation can name it. Types with special import
- * behavior own it through `coerceForImport`; the remaining legacy import
- * semantics stay here until they can move without changing error behavior.
+ * Deliberately not routed through the column-type registry: its contract is
+ * "coerced or rejected", while an import needs invalid raw text to survive so
+ * row-level validation can name it. A registry value import here would also
+ * pull every column-type implementation into each client that previews CSVs.
  */
 export function coerceValue(
   value: unknown,
@@ -481,9 +481,6 @@ export function coerceValue(
 ): string | number | boolean | null | Record<string, unknown> | unknown[] {
   if (value === null || value === undefined || value === '') return null
 
-  const importValue = columnTypeById(colType).coerceForImport?.(value, options)
-  if (importValue !== undefined) return importValue
-
   switch (colType) {
     case 'number': {
       const n = Number(value)
@@ -504,6 +501,9 @@ export function coerceValue(
     case 'date': {
       return normalizeDateCellValue(String(value), options) ?? String(value)
     }
+    case 'ttl': {
+      return parseTtlEpochSeconds(value, options) ?? String(value)
+    }
     case 'json': {
       if (typeof value === 'object') return value as Record<string, unknown> | unknown[]
       try {